Connect a client, make a call, read the bill.

1. 1

   Create an account

   Sign up with an email address. There is no password: creating the account and signing in both work by a link emailed to you, valid for 15 minutes and usable once. Nothing is created until you open that link.

2. 2

   Mint an API key

   In the dashboard, create a key. It is shown once, at creation, and only its prefix is stored in readable form afterwards. There is no way to retrieve it later, so save it then.

   Give it the scopes it needs and no more. A key without runs:execute can search, inspect and read usage docs, and will be refused by omnial_execute. A per-key spend cap bounds what that key can spend in aggregate.

3. 3

   Point your MCP client at the endpoint

   The endpoint is below, the credential is an Authorization: Bearer header, and the config block for your client is in the next section.

4. 4

   Ask your agent to find a tool

   If the connection is healthy, eight tools appear in your client. Ask it to search the catalog for a capability and it will use them.

Setting this up with an agent instead of doing it by hand? Send it /SKILL.md, a plain-text document written for an agent to read and act on directly, with no JavaScript and no sign-in required to fetch it. The same document, with the config for your specific client and a copy button, is on the install page. (The older /install.md URL serves the identical body and is not going away.)

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

Authorization: Bearer omn_live_REPLACE_WITH_YOUR_KEY

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

claude mcp add --transport http omnial https://mcp.eden-engine.com/mcp --header "Authorization: Bearer omn_live_REPLACE_WITH_YOUR_KEY"

{
  "mcpServers": {
    "omnial": {
      "url": "https://mcp.eden-engine.com/mcp",
      "headers": {
        "Authorization": "Bearer omn_live_REPLACE_WITH_YOUR_KEY"
      }
    }
  }
}

{
  "mcpServers": {
    "omnial": {
      "serverUrl": "https://mcp.eden-engine.com/mcp",
      "headers": {
        "Authorization": "Bearer omn_live_REPLACE_WITH_YOUR_KEY"
      }
    }
  }
}

{
  "$schema": "https://opencode.ai/config.json",
  "mcp": {
    "omnial": {
      "type": "remote",
      "url": "https://mcp.eden-engine.com/mcp",
      "enabled": true,
      "headers": {
        "Authorization": "Bearer omn_live_REPLACE_WITH_YOUR_KEY"
      }
    }
  }
}

import asyncio
import os

from agents import Agent, Runner
from agents.mcp import MCPServerStreamableHttp

# export OMNIAL_API_KEY=omn_live_REPLACE_WITH_YOUR_KEY
OMNIAL_API_KEY = os.environ["OMNIAL_API_KEY"]


async def main() -> None:
    async with MCPServerStreamableHttp(
        name="omnial",
        params={
            "url": "https://mcp.eden-engine.com/mcp",
            "headers": {"Authorization": f"Bearer {OMNIAL_API_KEY}"},
        },
        cache_tools_list=True,
    ) as omnial:
        agent = Agent(
            name="Assistant",
            instructions=(
                "Use omnial_search to find a tool, omnial_learn to read its usage "
                "instructions before calling it, and omnial_execute with dry_run=True "
                "to check cost before spending."
            ),
            mcp_servers=[omnial],
        )
        result = await Runner.run(agent, "Find a tool that can search the web and tell me what it costs.")
        print(result.final_output)


asyncio.run(main())

# export OMNIAL_API_KEY=omn_live_REPLACE_WITH_YOUR_KEY
[mcp_servers.omnial]
url = "https://mcp.eden-engine.com/mcp"
bearer_token_env_var = "OMNIAL_API_KEY"

{
  "mcpServers": {
    "omnial": {
      "command": "npx",
      "args": [
        "-y",
        "mcp-remote",
        "https://mcp.eden-engine.com/mcp",
        "--header",
        "Authorization:${OMNIAL_API_KEY}"
      ],
      "env": {
        "OMNIAL_API_KEY": "Bearer omn_live_REPLACE_WITH_YOUR_KEY"
      }
    }
  }
}

The MCP tools are named omnial_* because this product is Omnial MCP (in full, Eden Omnial MCP), one product under the Eden Engine umbrella. The names are part of the wire protocol your client speaks, so they are shown here exactly as your agent will call them.

A run that failed

Comes back as an error result, from omnial_execute and from omnial_run_status alike: a failed paid call is never indistinguishable from a successful one. QUEUED and RUNNING are not errors: the hold is taken and the job is live.

Not enough balance

A dry_run answers with sufficient_balance: false and the shortfall rather than failing opaquely. A real call in the same state is refused before any provider is contacted, and nothing is charged.

An unknown category or slug

Refused, naming what is valid. Silently matching zero rows would read as “this catalog cannot do that”.

Cancel on a tool that cannot be stopped

Refused, naming the tool. Stopping a job is a capability a provider has to declare; no tool in this catalog declares one today, and releasing your hold while the provider keeps working would be worse than saying no.

A tool this deployment cannot execute

Withheld from search results and counted separately, with the cause named. A missing provider credential is a fact about the deployment, not about the catalog.

Inline output: 32 KiB

Larger provider output is replaced by an envelope saying it is not the result, how large the real one is, and where to fetch the whole thing with the same API key. Nothing is discarded. Truncation is a delivery decision, never a storage one.

Provider response: 16 MiB

A response larger than this is refused loudly as a typed failure naming the limit and the bytes read, and the connection is cut rather than drained.

Rate limits

omnial_inspect returns the per-key and per-workspace request rates your calls are held to. The public catalog and its search are rate-limited per address.

Spend

Bounded by your balance, by any per-key spend cap, and, on any single run, by the enforced ceiling of 2x its quote. The quote itself is what gets held while the call runs; it is not a cap on the charge.

Both limits are enforced, not just documented: an inline result over 32 KiB is replaced with a fetch link rather than silently cut, and a provider response over 16 MiB is refused outright and the connection closed rather than drained to fit.

One more thing worth knowing before you wire this in: calling these tools to power your own product, under your own brand, is permitted; making our catalog itself — the listings, the hand-authored usage docs your agent reads through omnial_learn, or this directory's agent-tool surface — what you offer your users, in whole or in substantial part, whether copied or proxied live, is not. See /legal/terms#acceptable-use for the policy, and /why#whitelabel for worked examples of it. Integration permission is separate from data-use restrictions: a provider's data still carries its own, listed in the same /legal/terms#acceptable-use section.