AI Fleet

Dependable AI that recovers. ClearCode and Fusion, combined: governed agents that run on hardware you own, routed across models no single vendor controls.

Two halves of one system

An AI agent needs somewhere to run and something to think with. ClearCode is the first. Fusion is the second. Run them together and you have a fleet of autonomous agents whose execution, model choice and spending all stay under your control.

ClearCode — the execution seat

  • A sovereign local seat for each agent, running on your hardware.
  • Sandboxed tools with explicit, configurable reach.
  • Tamper-evident receipts for every action an agent takes.
  • Agents keep working when the network does not.

Fusion — the routing gateway

  • One entry point in front of every model you use.
  • Routes each turn by task, context size and cost ceiling.
  • Failover circuits, so one dead provider is not an outage.
  • Model independence: swap a model without touching an agent.

Why they ship together

Separately, each solves half the problem. A local execution seat with no routing is tied to whatever model you hard-coded into it. A routing gateway with no governed seat has nothing trustworthy at the other end. Together they give you the property that matters commercially: the model is a configuration choice, not an architecture decision. When a vendor changes a price, retires a model, or releases something better, you change one entry and the fleet follows.

You do not go down when a vendor cuts you off

Every organisation running on a single AI provider has accepted a dependency it cannot see the inside of. A safety classifier misfires on ordinary business text. An account is flagged for review. A model is deprecated on six weeks' notice. A region goes dark, a rate limit lands mid-quarter, or a billing hold stops an API key at nine in the morning. None of these require anyone to have done anything wrong, and none of them are things you can appeal in time to matter.

On a single-vendor stack, each of those is an outage. Work stops until someone else fixes something you do not control.

On an AI Fleet, they are routing events. The agents themselves are running on your hardware, inside ClearCode, so no vendor account action can reach them. Fusion sits in front of several providers and your own local models at once, and when one refuses a request, the request moves. What was an outage becomes a line in a log.

Single vendor

  • Classifier false positive → the request fails, and so does the task.
  • Account review or billing hold → every agent stops at once.
  • Model retired → you rewrite prompts against a deadline you did not set.
  • Provider outage → you wait, and explain.

AI Fleet

  • A refusal on one route is retried on another, automatically.
  • Local models keep running with no provider, and with no network at all.
  • Swapping a model is a configuration entry, not a migration.
  • Failover circuits isolate a sick provider instead of spreading its failure.

To be precise about the limit: if a specific task genuinely needs a frontier model and that vendor is unavailable, that task is degraded until it returns. What does not happen is the rest of your operation stopping with it. The routine majority of the work never depended on that vendor in the first place, and it keeps running.

What it runs on

Open-weight models on your own hardware carry no per-token bill. Frontier models stay available through the same gateway for the work that genuinely needs them, under a spending ceiling you set. Nothing forces a cloud round trip, and nothing stops one when it is worth making.


← Back to Home