See agent activity
Follow sessions and requests, review model-call details, and understand how agents are using your AI services.
The open-source control plane for AI
AI at work.
In view.
Manage AI coding agents, models, and machines across your organization—from one place. See what’s running, where it’s running, and what it’s doing.
Self-hosted. MIT licensed. Built for teams.
ILLUSTRATIVE WORKSPACE
AgentsClaude · Codex · Copilot
RUN
Control planeSessions · activity · access
LIVE
Machines & modelsOllama · Strata · Docker
HOST
What is AI Control Mesh?
The layer between your
coding agents and your AI.
AI Control Mesh is a self-hosted server, a web console, and lightweight programs for the computers in your organization. Together, they connect the tools people use to the models, machines, and shared tools your team provides.
Keep using coding agents such as Claude Code, Codex, GitHub Copilot CLI, Qwen Code, OpenCode, Aider, and Goose. Launch supported agents through the mesh to record their model traffic, choose a compatible provider, and optionally share their terminal.
A control plane, not another model
It does not train a model or replace your coding agent. It gives you a shared place to route requests, inspect activity, manage model infrastructure, and decide who can use it.
A clearer way to run AI
Bring your AI operation
into one view.
As agents spread across teams and machines, visibility and coordination matter. AI Control Mesh gives you a shared place to manage the moving parts.
Manage a machine fleet
Connect the computers running your models and agents. Manage providers, launch agents, and reach a shared terminal.
Choose where AI runs
Route supported agents to local models on your machines or to hosted APIs. Mix providers to fit your setup.
Make it work for teams
Organize people into teams, share sessions intentionally, and grant access to the machines each group needs.
From a request to a conversation
Follow live model output, token usage, and response timings. Enable full traces to inspect prompts, replies, and tool calls, then revisit the recorded conversation when you need to understand an agent’s work.
More than a list of machines
Inspect CPU and GPU load, manage models on supported providers, start model-serving containers, and read logs. Machines can also share MCP servers: tools and context that selected agents can use across the fleet.
Stay close to long-running work
With terminal sharing enabled, watch an agent from a browser or phone and respond when it needs input. Launch agents remotely on machines that have explicitly enabled it, inside their configured project folders.
One connected system
Your agents.
Your infrastructure.
One mesh.
AI Control Mesh connects agent computers and model machines to a central server. Machines connect outward, so you can bring your own fleet without opening inbound ports on each one.
See how it’s built⌘Agent computersRun the tools your teams use
▦Model machinesBring local providers and tools
AI Control Mesh
Route · record · coordinate
A shared control plane for your AI operation
Inside the mesh
One hub.
Three distinct roles.
A developer’s laptop runs the client. A model host joins the fleet. Your server coordinates both. A single computer can fill more than one role.
Your existing coding agents
Developers keep their familiar terminal tools.
agent launches the toolagent-proxy carries its trafficWeb console
Connects to the server API for activity, sessions, machines, and access.
AI Control Mesh
Routes and records agent traffic. Owns configuration, accounts, and session sharing.
agent-serverYour models and tools
agent-machine connects the host to your server.
- Ollama, Strata, Docker Model Runner
- Model-serving containers
- Shared MCP servers
Vendor APIs and accounts
Supported hosted APIs or an agent’s own account service.
The server coordinates. It asks a fleet machine to manage its models, containers, and tools; it does not run those workloads itself.
The machine executes. Model management and remote launches happen on the selected machine, subject to its enabled features and access grants.
Follow one request
From a coding task
to a visible session.
Here is the path for an agent using a local model. Replies stream back along the same route while the server records the request.
- 1
Launch an agent
The client asks the server for a session, then starts your coding agent with the right connection settings.
- 2
Carry the request
The agent calls its computer’s loopback proxy. That proxy sends the request to your central server.
- 3
Reach the model
The server selects the session’s backend and uses the fleet machine’s tunnel to reach its local model server.
- 4
Stream and record
The reply returns to the agent. The console shows activity and timings; full traces are available when enabled.
Use infrastructure you own
Send supported agents to compatible Ollama, Strata, or Docker Model Runner backends. Ollama requests are translated and tuned; native-compatible backends receive pass-through traffic.
Keep a hosted provider
Route supported hosted API traffic through the server and record it alongside your local-model sessions. The provider still receives and processes those requests.
Keep the agent’s own service
Supported account agents continue talking to their vendor. Their HTTPS is captured using a server-managed certificate authority trusted by the launched process tree—not redirected to a local model.
Provider compatibility depends on the agent and protocol. Local routing does not make an agent offline, and hosted or account traffic still leaves your infrastructure.
Built around your organization
Start with one team.
Connect the rest when ready.
Bring scattered agent sessions and model machines into a shared operating model, without making every developer use the same agent or provider.
Share a model machine
Connect a GPU workstation, manage its supported model servers, and grant the right teams access. Developers can use it without running a model on every laptop.
Understand agent behavior
Inspect requests, timings, token counts, and captured conversations to investigate a failed task or compare how agents use a model.
Check on remote work
Launch an agent on an enabled fleet machine, follow its shared terminal from your phone, and respond to a prompt without sitting at that computer.
Share access deliberately
Accounts belong to organizations and teams. Session visibility and permission to type are separate choices. Machine grants control features such as launches, terminals, model management, and MCP access.
Your infrastructure, your responsibility
Remote launches and terminals can run commands. Machines must opt in and restrict project roots. Captured prompts and replies can contain sensitive data: protect the server, use HTTPS, and choose what you record and share.
Open source by design
Your AI infrastructure
should be yours.
Run AI Control Mesh on infrastructure you control. The permissive MIT license lets you use, modify, and redistribute it, including commercially, subject to its terms. Inspect the code and adapt it to your organization.
Make it your own
A practical path
from checkout to mesh.
Run your server
Deploy with Docker or Python, put HTTPS in front of it, and create the accounts your team needs.
Deployment guideConnect your computers
Install the client where developers run agents. Add fleet machines where you want to host models, shared tools, or remote agent work.
Getting startedLaunch, inspect, and share
Choose an agent and compatible provider. Start a session, review activity, and enable tracing or terminal sharing when you need them.
Supported agents
More visibility. More choice. Your control.