One call, from “I need a capability” to a settled charge.

Your agent connects to one endpoint with one credential. Five steps: search, inspect, learn, run, settle. eight tools, and money that is held before the call and settled after it.

Install it New to MCP? Start here

Five steps: search, inspect, learn, run, settle.

In the order an agent takes them. Only one of them spends anything.

Search for a tool by the words you would type
omnial_search
A keyword query comes back as a ranked list, best first. Every hit carries match_reasons: which keyword it hit, which query terms appear in its name, its category or its description, or a note that nothing matched and this is the nearest entry.
It always answers. An empty list means the catalog holds none of those terms, not that the engine declined to rank. The relevance beside each hit is that hit's score over the best score in the same answer, not a probability and not comparable between queries.
Filtering by a category that does not exist is refused, with the list of real categories attached. A typo that silently matched zero rows would read to an agent as “this catalog cannot do that”.
Inspect the contract before committing to it
omnial_inspect
The full contract: input schema, output schema, the pricing model, a cost estimate for the exact input you pass, and the rate limits your key and workspace are held to.
The input is validated against the tool's own schema before it is priced. Quoting a confident price for an input the tool would reject sends an agent off to budget for a call that can never run.
Learn from a guide written for an agent
omnial_learn
Returns the tool's usage.md, byte for byte: the full document, not a summary. It is not published on the website, so this call is the only way to read it. It is written for a reader who has already chosen the tool: what the parameters do and how they interact, the patterns that work, the failure modes to expect, and the shape of the bill.
Every tool has one. Each guide is written for its tool and checked against the tool's input schema, so its worked examples are valid calls.
Run it: price the call, then make it
omnial_execute
dry_run: true prices the exact input and spends nothing. No provider is contacted. It answers the affordability question rather than failing it: not enough balance comes back as sufficient_balance: false with the shortfall, not as an opaque error.
For real, the run holds its quote before the provider is called. That hold is what the call is expected to cost, not a cap on the charge: settlement follows what the call actually cost, never more than the hold (2x the quote at most). Fast tools return inline; anything slower returns a run handle.
Provider output is capped at 32 KiB inline. Past that the result is replaced by an envelope that says it is not the result, how big the real one is, and where to fetch it whole. An agent that pays for a call and then loses its context window to the answer has been served badly.
Settle: charge the actual, release the rest
On success the actual cost is charged and the remainder of the hold released. Where the call cost more than its quote, the excess is charged too, up to the hold, so the balance never goes below zero. Past the hold we absorb the difference and quarantine the tool. On failure the hold is released in full: a run that did not come back is not charged for.
The ledger is append-only and every entry carries a full balance snapshot, so each run's page can show estimated, held and actual side by side with the entries that moved the money.

Settlement runs the same three bands on every call: at or under the quote you pay the actual cost, above it up to 2x the quote the excess is charged too, and past that the platform absorbs the rest and pulls the tool from the catalog. The 32 KiB inline cap is enforced identically for every provider, with no per-tool exception.

Metered per call, against a balance you put there first.

No plan, no seat. No monthly minimum. Top-ups start at $0.50. You pay the price shown. If a call turns out to cost more than its quote, you pay the actual price, capped at twice the quote.

The balance is prepaid, and every run moves through it in two steps rather than one: the quote is held while the provider works, and the actual cost is charged when it answers. That is what makes a failed call free and a cheap call cheap: you are not billed the estimate, you are billed the result.

Amounts are integers of a billionth of a dollar end to end, on the wire and in the ledger, so a charge far below a cent is exact rather than rounded into existence. An agent can read its own balance mid-task and decide whether it can afford the next move.

What moves, and when

Search, inspect, learn: Free. No provider is contacted and no money moves.
dry_run: Free. Prices the exact input and answers whether the balance covers it.
Execute: Holds the quote, calls the provider, then charges what it actually cost and releases the remainder. A charge above the quote never exceeds the hold, which is at most 2x the quote.
Failure: Releases the hold in full.

If the balance runs short mid-run

The hold is taken before the call, so what you can be charged is always covered. If the call costs more than its quote you are charged what it used, never more than the hold, and your balance cannot go negative. A run your balance does not cover is refused with the amount you need. Auto top-up is the setting to turn on before your agent has anything to do.

The full charge model, itemised, is on the pricing page.

A long job does not finish inside a request.

Anything slow returns a handle instead of a result, and three tools cover what happens next.

Poll it

The handle is opaque and is passed back as an argument. Nothing in this system keeps session state. A run that failed is reported as a failure here, not as a success with bad news in the text.

omnial_run_status

Find one you lost

Handles are stateless, so an agent whose process restarted has no other way to find the runs still holding its money. It lists this workspace's runs, in-flight by default.

omnial_runs

Stop one

Asks the provider to stop the job, then settles the run as cancelled and releases whatever is left of the hold. Stopping a job already in flight can still cost you what the provider had incurred by then, where it reports one.

omnial_cancel

No tool supports stopping a call yet.

Stopping a job in flight is something a provider has to declare, and no tool in this catalog declares one yet. So omnial_cancel refuses, naming the tool, rather than releasing your hold while the provider keeps working and keeps billing.

Eight tools, not one per catalog entry.

Listing a whole catalog through MCP would use tens of thousands of tokens of an agent's context before it did any work, so the catalog sits behind these tools.

omnial_search
Find tools by keyword. Each hit says why it matched.
Why
It always answers with what it found. An empty list means the catalog has none of those terms, not that the engine declined to rank.
Tuned to answer rather than refuse: returning a tool you can decline beats returning nothing, so search always ranks what it found. Relevance is shown relative to the best match in that answer, not as a probability, and every hit says which keyword or field it matched on, so a weak match shows as a weak match.
omnial_inspect
The full contract: schemas, pricing, and a cost estimate for your input.
omnial_learn
A usage guide for a tool you picked: what its parameters do, worked examples, failure modes, cost shape.
Why
Each guide is written for its tool and checked against the tool's schema.
omnial_execute
Runs the tool. dry_run prices a call without spending anything.
Why
The quote is held while the call runs and the charge follows what the call actually cost.
A quote is an estimate, not a promise of the final price: we hold the quote, or up to 2x the quote on a tool whose final price is only known when the call ends, and you pay the call's final price, never more than the hold. A call can never take your balance below zero, and Eden Engine absorbs anything above the hold.
omnial_run_status
Polls a run handle for anything that could not return inline.
omnial_balance
Available and held balance, so an agent can plan its own budget.
omnial_cancel
Stops a run you no longer want and releases what is left of its hold.
Why
The provider is asked to stop the job first, then the run settles as cancelled. Stopping a job that is already running can still cost what the provider had incurred by then, where it reports one.
No tool supports stopping a call yet. Stopping a job is something a provider has to declare, and no tool in this catalog declares one today, so cancel answers with a refusal naming the tool. Releasing your hold while the provider keeps working would leave the cost with nobody. A synchronous run is refused too: abort your own request instead, which aborts the provider call with it.
omnial_runs
Lists this workspace's runs, newest first. By default only the ones still in flight.
Why
Run handles are opaque and stateless, so an agent whose process restarted has no other way to find the runs it left behind. Returns handles omnial_run_status and omnial_cancel accept.

The tools are named omnial_* because they are Eden Engine's. The names are part of the wire protocol your client speaks, so they are shown exactly as your agent calls them.

What the loop looks like in practice.

The calls behind steps one to four. Settlement happens on our side after the run. Inputs are illustrative; every tool page carries the same block filled in for that tool.

agent

// 1. find a tool for the job, in the words you would type
omnial_search({ query: "scrape a web page as HTML" })
//    returns ranked hits, each with match_reasons and a set-relative relevance

// 2. read the contract and price YOUR input
omnial_inspect({
  tool: "omnial/web-scrape-html",
  input: { url: "https://example.com/product/1" }
})
//    returns input_schema, output_schema, pricing, estimate, limits

// 3. read the usage doc before calling it
omnial_learn({ tool: "omnial/web-scrape-html" })

// 4. price it for real, then run it
omnial_execute({ tool: "omnial/web-scrape-html", input: { url: "https://example.com/product/1" }, dry_run: true })
omnial_execute({ tool: "omnial/web-scrape-html", input: { url: "https://example.com/product/1" } })
//    returns a result, or a handle to poll with omnial_run_status

One endpoint, one header, one file on your machine.

There is nothing to install and no SDK to add to your project. Every client above speaks Streamable HTTP over one URL, authenticated by a static bearer header, so connecting is a config file and a key. Each client uses a different file and key names; pick yours and we'll write it.

The fastest version of all of this is not doing it by hand at all: hand your agent SKILL.md and it writes its own config, then tells you what it needs from you.

Install it Full connection docs

.mcp.json · Claude Code

{
  "mcpServers": {
    "omnial": {
      "type": "http",
      "url": "https://mcp.eden-engine.com/mcp",
      "headers": {
        "Authorization": "Bearer ${OMNIAL_API_KEY}"
      }
    }
  }
}

endpoint: https://mcp.eden-engine.com/mcp

See it against a real catalog entry.

Every tool page carries its full contract and its pricing model, itemised charge by charge. Eden Engine hands the complete usage guide to your agent separately, at runtime, not on the page.

Install it Browse the catalog How billing works

Live catalog

Eden Engine's catalog is live: real, working integrations are browsable at /tools and callable today. What's listed there is exactly what you can run right now, gated by the same live-provider check that decides what gets billed. The append-only ledger, hold-before-the-call and settle-after, the pricing engine and the eight MCP tools in front of all of it are the same infrastructure a live call actually runs on. The catalog keeps growing as more integrations clear verification and go live.