The software factory that ACTUALLY runs in your own cloud.
Your coding agents, in your cloud, under your control.


A flight across one architecture map. Today, coding agents run in YOLO mode on laptops full of production keys, and every agent is different. LLMonade merges them into one team agent on secure MicroVMs in your AWS account, where you control what they can reach. Webhooks and schedules start them. Every session's trace lands in one store. Mining those traces improves the agent for the whole team, and evals built from real tasks choose the right model for each task, which lowers the bill without lowering quality.
How it works
LLMonade gives you everything you need to run a self-improving software factory in your own AWS account. Your data stays safe.
Your team and your tools start sessions.
- Alex
- GitHub
- Linear
- Sentry
- Schedule
Everything else runs in your AWS account.
- Isolation & Data Sovereignty
A shared team agent runs in a MicroVM for every session.
Team agent
- MicroVMAlex's session
- MicroVMPR review
- MicroVMLinear task
- Compound Engineering
Session traces become new skills, so the team agent keeps improving.
Session traces
InsightsNew skill - Spend Governance & Task-Aware Routing
The AI gateway sends each task to the model that fits it.
Evals Haiku Sonnet Opus Update dependencies Passes, chosen Passes Passes Write tests Fails Passes, chosen Passes Plan a refactor Fails Fails Passes, chosen Cost $ $$ $$$$$
- Isolation & Data Sovereignty
Isolation & Data Sovereignty
Run agents on secure MicroVMs in your AWS account, with no credentials on the VM. Gateways in your account hold the keys, and you decide what agents can reach.
Every session gets its own MicroVM in your AWS account.
Your AWS account
- MicroVMAlex's session
- MicroVMPR review
- MicroVMLinear task
MicroVMs hold no credentials. Gateways keep them.
AI gatewayProvider keysMCP gatewayTool credentialsGit gatewayGitHub tokensYou decide what agents can reach.
- github.comAllowed
- linear.appAllowed
- Malicious domainBlocked
Compound Engineering
Every session trace is persisted to a centralized store in your account. Mine these traces to level up your agents, and the whole team benefits.
Every session leaves a trace.
Session traces
PR reviewLinear taskSentry fixAlexInsights show where agents can improve.
InsightsAgents don't understand durable functions
Appeared in 25 sessions
That becomes a new skill for the team agent.
Team agent
deployrun-testsauth-reviewmigrationsdurable-functionsEvery MicroVM gets it, so the whole team benefits.
- MicroVMAlex's sessionNew skill
- MicroVMPR reviewNew skill
- MicroVMLinear taskNew skill
- MicroVMSentry fixNew skill
- MicroVMNightlyNew skill
Spend Governance & Task-Aware Routing
Stop routing every task to the most expensive model. Benchmark models with evals from your own sessions, then let the AI gateway route each task, attribute usage, and enforce budgets.
Evals show which model each task needs.
Evals Haiku Sonnet Opus Update dependencies Passes, chosen Passes Passes Write tests Fails Passes, chosen Passes Plan a refactor Fails Fails Passes, chosen Cost $ $$ $$$$$ The AI gateway routes each task to that model.
AI gatewayUpdate dependenciesHaiku 5.5$Write testsSonnet 5.5$$Plan a refactorOpus 5.5$$$$$Your inference bill comes down.
Every task on Opus
Each task on its model
CFCFO
Great job on the bill! 🎉
Technical FAQ
Behind the rind
Your cloud. Your controls. Here’s how it works.
What runs inside our AWS account?
LLMonade's cloud infrastructure runs in your AWS account. The control plane manages access and session lifecycle. The AI gateway handles model requests. Isolated MicroVMs run the agents, while your storage holds workspace files, conversation history, and session records.
Your organization controls the infrastructure, network policies, and data. Model requests pass through the AI gateway so you can control model access, track usage, and enforce budgets. The gateway connects to your approved model providers.
The developer front end runs locally and displays the agent's actual terminal UI from the cloud. Developers interact with Claude Code, Codex, or another supported agent using its familiar interface. It looks and feels like a local session, with execution in your AWS account.
How do developers connect?
Developers authenticate through AWS IAM Identity Center using your organization's workforce identity. LLMonade uses an AWS profile backed by temporary credentials to authorize access to their agent sessions and connect to the MicroVMs running them.
IAM Identity Center integrates with Okta, Microsoft Entra ID, Google Workspace, CyberArk, JumpCloud, OneLogin, and Ping Identity. It also supports Microsoft Active Directory as an identity source.
Your administrators assign access through AWS permission sets, with separate developer and administrator roles. Human SSO credentials stay outside the agent's MicroVM.
What can an agent access?
An agent can reach the resources allowed by its runtime identity and network policies. Each session runs in an isolated MicroVM with storage permissions scoped to that session. Model requests use the configurable AI gateway; approved tool connections follow your tool-access policies.
Traffic leaving the MicroVM is routed through your VPC. Security groups, subnet network ACLs, and routing control access to internal services and external destinations. We help your infrastructure and security teams configure access to the repositories, APIs, and model services your engineers need.
You can configure advanced traffic inspection along that network path. VPC Flow Logs show connection metadata and accepted or rejected traffic. AWS Network Firewall adds filtering and can inspect supported encrypted traffic when TLS inspection and certificates are configured.
How are workspaces isolated and replaced?
Each coding session runs in its own MicroVM with a separate workspace and session-scoped storage permissions. Developers use a consistent workspace setup, while each session keeps its own files and conversation history.
The MicroVM workspace contains the repository and the agent's durable session state. Session files persist in your AWS storage and synchronize automatically to your S3 bucket.
The compute environment can be suspended or replaced while the session's files remain available. Developers can return to their work without maintaining a particular machine.
How do model requests work?
The coding agent sends model requests to a local relay inside its MicroVM. The relay routes them to a private AI gateway in your AWS account.
The gateway checks session authorization and supplies provider credentials on the server side. Provider keys stay outside the MicroVM and off developer laptops. Private networking and session authorization control access to the gateway.
The gateway provides a central point for approved model access, usage attribution, and budget enforcement. You can connect model spending to the sessions and developers doing the work.
What gets recorded?
LLMonade preserves the coding agent's native conversation history in your session storage. This includes developer messages, agent responses, and the tool calls and results captured by the agent. Instructions and corrections remain part of that history.
These records help your team extract useful lessons across developers: repeated failures, effective instructions, and successful approaches that can improve future sessions.
Access decisions and session operations have their own audit records. The AI gateway records model usage and cost, while your configured network monitoring provides traffic visibility.
During pilot setup, we agree on recording scope, retention, access, and redaction requirements with your security team.
What does a pilot involve?
A pilot starts with an internal champion, a group of engineers, and the infrastructure or security team that will administer LLMonade.
Together, we choose the coding agents and model providers, define access to repositories and internal services, and configure network security. We also agree on budgets, cost controls, session-data handling, and administrator responsibilities.
We scope the deployment and the workflows your engineers will try. Success means engineers completing useful work, administrators verifying the access boundaries, and your team understanding the operating effort and costs.
A demo shows how developers work with LLMonade and how administrators manage access, infrastructure, and costs.