Skip to content

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.

  1. Your team and your tools start sessions.

    • Alex
    • GitHub
    • Linear
    • Sentry
    • Schedule
  2. Everything else runs in your AWS account.

    • Isolation & Data Sovereignty

      A shared team agent runs in a MicroVM for every session.

      Team agent

      • MicroVM
        Alex's session
      • MicroVM
        PR review
      • MicroVM
        Linear task
    • Compound Engineering

      Session traces become new skills, so the team agent keeps improving.

      Session traces

      Insights
      New skill
    • Spend Governance & Task-Aware Routing

      The AI gateway sends each task to the model that fits it.

      EvalsHaikuSonnetOpus
      Update dependenciesPasses, chosenPassesPasses
      Write testsFailsPasses, chosenPasses
      Plan a refactorFailsFailsPasses, chosen
      Cost$$$$$$$$

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.

  1. Every session gets its own MicroVM in your AWS account.

    Your AWS account

    • MicroVM
      Alex's session
    • MicroVM
      PR review
    • MicroVM
      Linear task
  2. MicroVMs hold no credentials. Gateways keep them.

    AI gatewayProvider keys
    MCP gatewayTool credentials
    Git gatewayGitHub tokens
  3. You 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.

  1. Every session leaves a trace.

    Session traces

    PR review
    Linear task
    Sentry fix
    Alex
  2. Insights show where agents can improve.

    Insights

    Agents don't understand durable functions

    Appeared in 25 sessions

  3. That becomes a new skill for the team agent.

    Team agent

    deployrun-testsauth-reviewmigrationsdurable-functions
  4. Every MicroVM gets it, so the whole team benefits.

    • MicroVM
      Alex's sessionNew skill
    • MicroVM
      PR reviewNew skill
    • MicroVM
      Linear taskNew skill
    • MicroVM
      Sentry fixNew skill
    • MicroVM
      NightlyNew 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.

  1. Evals show which model each task needs.

    EvalsHaikuSonnetOpus
    Update dependenciesPasses, chosenPassesPasses
    Write testsFailsPasses, chosenPasses
    Plan a refactorFailsFailsPasses, chosen
    Cost$$$$$$$$
  2. The AI gateway routes each task to that model.

    AI gateway
    Update dependenciesHaiku 5.5$
    Write testsSonnet 5.5$$
    Plan a refactorOpus 5.5$$$$$
  3. Your inference bill comes down.

    Every task on Opus

    Each task on its model

    CF

    CFO

    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.