MCP hands an agent a tool.
Pilotage teaches it to use one.
MCP — the Model Context Protocol — is how AI agents plug into real systems. It gives an agent the tools. But a tool’s instruction sheet only lists the buttons; it never teaches the craft of using them. Pilotage is the layer that teaches the craft.
Think of the difference between being handed a car and being taught to drive. Most real work isn’t a single value typed into a box — it’s a small program: a query, a workflow, an automation rule, a filing. Pilotage lets the server that owns the tool do the teaching, once, for every agent — instead of every agent guessing on its own and hoping the first try lands.
Three gaps a schema
leaves wide open.
A schema describes structure. It can’t teach meaning, it can’t offer a second chance, and it can’t stop every agent re-learning the same system from scratch.
A JSON schema says a field is a string. It can’t say which strings are valid — the names, codes, and rules a real system enforces. The agent is left to guess, and guesses fail in production.
A plain tool call gives the agent a single blind attempt — no way to draft, check, or repair before something happens for real. On a destructive action, the first mistake is the last.
Today every agent re-learns every system from scratch — custom prompts, hand-built glue, brittle integrations. Knowledge that belongs on the server gets copied into each agent, over and over.
Learn. Check. Plan.
Execute. Trace.
Seven small capabilities the server can offer — a hub the agent drives, calling whichever it needs. Together they turn one blind shot into a whole program the agent can check before it runs.
Manifest
The handshake. On connect, the server declares what it can teach and how — so the agent knows Pilotage is available before it does anything.
Guides
Navigable, human-and-agent-readable documentation the server publishes about its own tools — the moves, the rules, the worked examples.
Catalog
A live, versioned view of the real environment — the valid names, records, and options that exist right now, not what a static schema guessed months ago.
Validate
The agent submits a draft and gets it checked with zero side effects. Clear diagnostic codes point straight at what’s wrong — before anything runs.
Plan
The server returns the exact steps it would take, each annotated with its risk — so a destructive action is seen and approved before it happens, never after.
Execute
The real work runs — only once the draft has been checked and the plan understood. One deliberate action, not one blind shot.
Trace
Every run leaves a verifiable record, stored by run ID — what was decided, why, and what happened. Auditable after the fact, by anyone.
Built to add capability —
without taking control.
Pilotage is deliberately conservative about what it changes. It gives agents more competence and more accountability, and asks you to give up nothing you already rely on.
The seven layers are a hub the agent drives, not a pipeline it’s forced through. It decides what to call, and when. Pilotage adds capability without taking away control.
Your SQL stays SQL. Your workflow format stays yours. Pilotage standardises how an agent learns, checks, and traces its work — never what your tools are made of.
No new transport, no new session model. If your system already speaks MCP, Pilotage is purely additive — negotiated through MCP’s own extension mechanism.
Pilotage makes a cooperative server more understandable and more checkable. It does not claim to make a malicious server safe — and it says so plainly.
An open standard for a
governed Digital Workforce.
A Digital Employee is only as trustworthy as the way it uses your systems. Pilotage makes that use teachable, checkable, and auditable — and we published it as an open standard so the whole ecosystem can build on it, not just us.
Validate-before-execute and risk-flagged plans mean our Digital Employees check their work before touching a live system — the difference between a draft and a done deal.
Every run leaves a trace stored by run ID. Governance and audit aren’t bolted on afterward; they fall out of how the work is done.
Pilotage is a published open extension of MCP — the same open standards posture behind the BeX platform. Any MCP server, ours or yours, can adopt it.
The Pilotage specification is open and public. Read the spec, explore the reference implementation, or try it against the live Harborview example server.