Universal MCP

A single MCP server, for your whole API estate.

Give agents one interface to your APIs, databases and streams. They ask for the data or action they need; Orbital works out how to get it done.

No MCP tools to build or maintain.

Get Started Read the docs

Don't turn your API estate into a tool list.

As you connect more APIs to MCP, the agent has more tools, more schemas and more choices to navigate.

Orbital gives the agent one semantic interface across your systems. It asks for what it needs; Orbital works out where to get it and what to call.

Semantic MCP
Agents can query and act across APIs, databases and streams without exposing every operation separately.
Less context, fewer choices
Keep hundreds of tool schemas out of the model’s context window.
Adapts as APIs change
Publish an updated schema and Orbital replans against the new model, without rebuilding MCP tools by hand.

Ask for what you need.

Agents don't need to work out how to navigate your services.

Orbital turns the request into a typed query, validates it, and plans the integration across your estate.

An agent asks for what it needs in plain language. Orbital turns that request into a query, works out which systems to call, orchestrates the calls, and returns a single response over MCP.

Agent

Pull up customer CUS-4821 - name, tier, open tickets, last contact and what they’ve spent.

agent-call.taxi

1// Orbital resolves that to one query - which still names
2// no service, no endpoint, and no order of calls.
3find { Customer( CustomerId == 'CUS-4821' ) } as {
4   name          : CustomerName
5   tier          : LoyaltyTier
6   openTickets   : TicketCount
7   lifetimeSpend : LifetimeSpend
8   lastContact   : ContactDate
9}

Receive

MCP · tools/call

Plan

Convert Text -> TaxiQL queryCall data sources

Resolve

CustomerApiLoyaltyServiceSupportDeskBillingLedger

Transform

nameCustomerName

tierLoyaltyTier

openTicketsTicketCount

lifetimeSpendLifetimeSpend

lastContactContactDate

Answer

Tool call result as JSON

Instant, deterministic orchestration.

Orbital builds the integration on demand, then runs it deterministically — without an LLM choosing tools, sequencing calls or handling the results.

Fast, repeatable execution, every time.

How queries execute

An execution plan: one query fanning out across a database and three services, with every returned field traced back to the call that produced it.

Let agents act across your APIs

Agents can invoke existing operations without a hand-written MCP tool for each one.

Orbital finds the right operation, resolves its inputs from the request and available context, checks authorisation, then executes it through the same deterministic runtime.

billing-address.taxi

// The agent asks for the outcome."Update this customer's billing address."
// Orbital resolves the operation that can deliver it,// works out the inputs from the request and the estate,// checks the caller is allowed to run it, then calls it.given { CustomerId = 'CUS-4821', address : PostalAddress }call BillingApi::updateBillingAddress

See what the agent actually did.

Inspect the execution plan behind every MCP request: the systems called, timings, transformations and the source of every returned value.

No extra instrumentation required.

Explore observability

A profiler listing every call in a request beside a sequence diagram of the services it touched, with timings.

Give agents broad reach without broad access.

Orbital lets agents work across your enterprise while enforcing context-aware policies down to individual fields - even when the answer is assembled from multiple systems.

Field-level authorisation
Control exactly which data each caller can see.
Context-aware policy
Use identity, request context and live data from connected systems to make access decisions.
Audit and lineage
See who asked, what ran, which policies applied and where every returned value came from.

Universal authorisation

Frequently asked questions

Got another gnarly question? We’d love to hear it. Come and chat on Slack.

: A conventional MCP server typically exposes individual operations as tools, so the tool set grows with the API estate.
Orbital gives the agent a semantic interface instead. The agent asks for the data or action it needs, and Orbital works out which systems and operations can satisfy the request.
: No. An LLM can turn a plain-language request into TaxiQL, but planning and execution happen in Orbital outside the model.
Orbital validates the query, resolves the required operations and executes the integration deterministically.
: The agent doesn’t need the schemas for hundreds of API-specific tools in its context window.
It works through one semantic interface, leaving more context for the actual task and reducing tool-selection ambiguity.
: Publish the updated schema and Orbital replans against the new model.
Compatible changes can be absorbed without rebuilding an MCP tool. If the request can no longer be satisfied safely, Orbital surfaces the problem rather than guessing.
: Yes. Orbital can resolve and invoke operations from connected APIs as governed actions as well as answering data queries.
Authorisation, input resolution and execution all happen through the same runtime.
: No. The agent connects to Orbital rather than directly to every underlying API or database.
Orbital handles access to the systems behind the request and evaluates authorisation before returning data or invoking an action.
: Yes. Orbital exposes a standard MCP server, so MCP-compatible clients can connect without Orbital-specific client tooling.
: Yes. Every request records the execution plan, systems and operations used, policies applied and lineage of returned data.
You can inspect how an answer was assembled and trace individual values back to their source.

Your API estate.
One MCP server.

Start with the schemas you already publish, connect your MCP client, and ask for what you need.

Start for free Talk to us

A single MCP server, for your whole API estate.

Semantic MCP

Less context, fewer choices

Adapts as APIs change

Instant, deterministic orchestration.

Let agents act across your APIs

See what the agent actually did.

Field-level authorisation

Context-aware policy

Audit and lineage

Your API estate.One MCP server.

Your API estate.
One MCP server.