Scaling Agents

One agent is a demo. A thousand is an operating model. Deploy workflows across Amazon Bedrock, Vertex AI and Microsoft Foundry and watch the agents talk to each other. Then see what it takes to keep them in check once nobody can name them all.

It asks you to accept a few realities. Teams with autonomy will do things their way, and the game pokes a little fun at that. Scaling is hard, and what it takes to manage AI at scale is very different from what got you through experimenting.

Cash
£0
 
Net per second
£0
 
Agents
0
 
Trust
100
 
Quality
100%
 
Traced
0%
Incidents
0
 

Inject into

Needs your approval

Auto-approve

    How the traffic works

    Your platform Kubernetes in your DCruns the orchestrators Each cloud Agents on its runtimecall models via its gateway Context layer Knowledge, docs, data, memory, skills MCP tools SaaS appsCRM, helpdesk, Git hand off read context, call tools API Your platformKubernetes in your DC, orchestrators hand off Each cloudAgents on its runtime, models via its gateway read context, call tools Context layer Knowledge, docs, data, memory, skills MCP tools API SaaS apps: CRM, helpdesk, Git
    • HandoffsOrchestrators run on Kubernetes in your own data centre. They hand work to agents running in a cloud: on AgentCore Runtime or EKS in AWS, Agent Engine or GKE in Google Cloud, Foundry Agent Service or AKS in Azure. Agents hand off to each other over an agent-to-agent protocol such as A2A.
    • Model callsEach agent calls models in its own cloud, prompt in and tokens out, through that cloud’s AI gateway: token limits, keys and region rules, close to the agent. Your data centre runs its own gateway too, self-hosted, for its orchestrators’ calls. Gateways in different clouds can’t help each other in an outage unless something routes between them: federate them through the one in your data centre and it becomes the hub.
    • Reading contextBefore each model call, an agent reads what it needs: business knowledge, documents, data or memory. This layer is the one worth centralising. With a context platform every agent reads the same current copy; without one it reads its own copied files (the grey squares), which go stale. That’s what drags Quality down.
    • Skills and schemasWith shared standards, agents load the same skills and output formats from one library, so the next agent can read what the last one wrote.
    • ApprovalsBefore anything risky (a refund, a payment, a merge) an agent asks. Governing agents go to it, score the risk as low, medium or high, and approve what your policy allows. Everything else comes to you, with their recommendation. They judge with what the platform shows them: the policy in the context layer, a trace back to the original request, and the agent’s identity. Without those they miss more, so auto-approving medium risk is only safe once they can see.
    • Tool callsTo act in a real system, an agent calls an MCP server, which calls the app’s API and returns the result. Each cloud has its own way in (AgentCore Gateway, for one, turns APIs into MCP tools), but what they reach can be one shared set. MCP servers aren’t agents, and one serves every workflow that needs it.

    Live traffic

      Incidents

        Recent events

          Scenarios

          Each one starts an estate with something missing and lets you watch what slips. Switch it on and watch it recover, or compare the two over many runs. Your own game is kept safe while a scenario plays.