Capability

Business systems as safe agent tools

Agents acting on payments, email, social platforms and private APIs without holding a key, with every action attributed

Rust · Model Context ProtocolOAuth 2.0 identityThree provider APIs rebuilt
Agents hold no keys · the gateway holds them all
Vendor events come back, signed, to the team that caused them
354tools rebuilt from three providers' APIs
  • 0provider keys held by any agent; every credential stays server-side
  • 7 of 14function crates in the estate carry the tool generator's fingerprints
  • 1 personapproves every grant an outside assistant receives, on the consent screen

Agents that do real work against real services need credentials, and the moment one holds a credential there is a key in a transcript, actions nobody can attribute, and a crash window where a charge is doubled or lost.

I built a governed gateway that exposes provider tools, each rebuilt from the provider's API, to managed agents, with credentials held server-side and identity derived from the authenticated caller, so no tool argument can claim to be someone else. Start with Agents with real tools and no keys.

The crash window around one provider call

A restart inside the shaded gap either repeats the call or forgets it. Durable accounting wraps every call, so a restart never repeats a provider call, and the customer, price or post the vendor created is captured and tied to the assignment that created it.

Out · one steady surface
stable namespaces across three providers
each business isolated: its own repository, subdomain, provider namespace and mailbox
Back · the vendor's events
a payment, a reply, a bounce, signed and durable
delivered in frozen batches to the mailbox of the team lead whose assignment caused them
Per-provider capability table
round-trip shown for that operation under that API version: attribution written into the vendor payload
not yet classified: the tool works and is accounted; attribution kept on my side
a mutation whose metadata was unproven: left disabled until checked
Illustrative mix.

Attribution that might be silently dropped is worse than none.

I built the substrate that turns one function definition into an orchestrated, budgeted, agent-callable tool, and a generator that lets agents write new tools inside a sandbox that becomes callable only after a human restart. See Tools that build tools, under governance.

One generated function · fourteen files
8 framework files the author must not modify
6 sandboxed: logic written against a context object, never a raw connection

Four services edited in one rollback-protected transaction; a symmetric delete reverses all of it.

The one human gate
GenerateBuildHuman restart✓

Link-time registration: a function is fully wired or the build fails. Reads pass a schema resolver that validates every identifier; writes go only through the governed queue.

The gate sits exactly at the privileged step, the rebuild and restart, and nowhere else.

And I built the access plane that lets commercial assistants connect to a private tool estate on my terms. See The hardening fix that locked everyone out.