Coding agent, then gateway, then model, then tokens.
The gateway receives
- prompt“add retry…”
- tokens3.4k in · 612 out
- latency1.8 s
- statusHTTP 200
The infrastructure sees the request.
AirLLM platform · AI infrastructure for coding agents
From keystroke to GPU — and back.
AirLLM connects the coding agent, model router, compute, and control plane into one task-aware system. Each step can be routed for the work it is doing — and the result can shape what happens next.
Agent · Router · Compute · Control
You› add retry to the payments webhook
request
AirCodecoding agent
- Plan
- Edit
- Run
- Verify
task context
step: run testAir Routerrouting
- Understand
- Size
- Route
- Fall back
selectsrun test→fast model
outcome✓ tests passed
Claude / OpenAIfrontier models
AirGPUAirLLM lane
Result
- tests passed
- build green
- task complete
outcome signalThe loop most AI stacks are missing.
The Missing Context
A model gateway sees a request. AirLLM can see the work around it.
AirCode — plan, edit, run, verify — then Air Router, then model or compute, then the task outcome, which loops back to Air Router.
Air Router can also see
- stepverify
- buildpassed
- answeraccepted
- loopdetected
- providerhealthy
The infrastructure can understand where the request sits inside the task.
Tokens are an input. The finished task is the outcome.
Task-Aware Routing
Route the step, not just the prompt.
A coding task isn’t one model call.
Planning, searching, editing, running commands, fixing errors, and verifying results have different requirements.
Because AirCode and Air Router are designed as parts of the same system, the agent can tell the routing layer what kind of work is happening. Then Air Router can choose accordingly.
Signal
step = planningNeedReasoning
RouteStronger model
Signal
step = toolNeedSpeed
RouteFast model
Signal
step = editingNeedCoding quality
RouteCoding model
Signal
step = executionNeedLow-cost coordination
RouteEfficient lane
Signal
step = verificationNeedConfidence
RouteQuality-aware route
The model can change while the task stays the same.
The Closed Loop
The result of this step can improve the next decision.
Most routing systems make a decision at request time. AirLLM can also receive signals from the work that happens after that decision.
① Understand
What is the agent doing?
- planning
- editing
- tool call
- verification
② Route
What should run it?
- task difficulty
- model fit
- provider health
- cost
③ Execute
Model / AirGPU
- frontier model
- efficient model
- AirGPU lane
- fallback provider
④ Observe
What happened?
- answer empty
- provider worked
- quality retry
- loop detected
- task check passed
- Empty answerDemote and retry
- Provider succeedsPreserve the working route where appropriate
- Quality insufficientRetry stronger
- Run begins loopingStop before unnecessary spend continues
Closed-loop routing.
The routing decision doesn’t have to end when the model responds.
Built Together
Four layers. One feedback path.
04 Control · Control Plane
01Build
AirCode
The agent that knows the task.
Plans, edits, runs commands, tests, and verifies work.
- Plan
- Edit
- Run
- Verify
sends task context ↓
02Route
Air Router
The intelligence between the agent and the models.
Understands task difficulty and step context, chooses an appropriate model lane, maintains prompt-cache behavior, handles provider failures, and helps protect against runaway work.
- task difficulty
- step context
- model lane
- prompt cache
- provider failover
- runaway protection
chooses execution ↓
03Run
Frontier Models + AirGPU
Use the compute the step deserves.
AirLLM’s own GPU lane for selected routine work, with fallback to upstream models.
outcome ↑
Govern the work, not three separate vendors.
- model policies
- budgets
- roles
- SSO
- usage
- cost
- agent sessions
- billing
One Operating Layer
The agent, API, spend, and policy meet here.
Control PlaneEngineering/OverviewLive
Live Sessions 1 running
Veeru / payments-apiRunning
AirCode
- Current step
- VERIFY
- Model lane
- airllm-auto
- Cost
- $0.42
PauseEnd
Model Governance
- Claude familyAllowed
- OpenAI familyAllowed
- ExperimentalBlocked
Budget
- Team
- Engineering
- Weekly budget
- 74%
$0weekly limit
One identity
The same platform identity follows the developer and API usage.
One spend layer
Agent and API consumption are visible together.
One policy
Model rules and organizational controls apply across the platform.
One view
See usage, task cost, and running agent activity without stitching together separate systems.
AirGPU
Not every step needs a frontier model.
Coding agents generate a surprising amount of work around the difficult reasoning: tool coordination, routine transformations, and other lower-complexity steps.
Air Router can place selected routine work on AirLLM’s own GPU lane while keeping frontier models available for demanding work.
Own the efficient lane. Reach the frontier when the task needs it.
Task
Air Router
RoutineAirGPUAirLLM-operated
fallback
DemandingFrontier Modelsupstream providers
tool coordination · routine transformationsdifficult reasoning
Result
Open at the Edge
Use our agent. Or bring yours.
AirLLM becomes more deeply task-aware with AirCode, but adopting AirCode isn’t required to use Air Router.
- Claude Codeguided setup
- Codexguided setup
- Cursorcompatible endpoint
- GitHub Copilot CLIguided setup
- OpenCodeguided setup
- Aiderguided setup
- AirCodeAirLLM-native
- task context
- lifecycle signals
- outcome signals
Open to other tools. Deeper when the stack is AirLLM-native.
One Platform
Add layers without adding integration work.
One key
One way into the platform.
Use AirCode or call Air Router without maintaining disconnected provider credentials across every workflow.
One bill
See AI consumption together.
Agent usage, routed API traffic, and eligible compute consumption share the AirLLM commercial layer.
One policy
Set the rules once.
Model governance, budgets, organizational roles, and access controls live at the platform layer.
One dashboard
See the work and the spend together.
Understand usage and cost while also seeing the state of AirCode sessions.
The value isn’t having fewer dashboards. It’s having one system that understands what those dashboards are measuring.
Platform Products
Enter the platform wherever you need it.
- AirCodeAI coding agentPlan, edit, run, and verify software in the terminal with AirCode CLI or on your desktop with AirCode Studio.Explore AirCode →
- Air RouterIntelligent routing layerOne compatible endpoint with routing, caching, fallback, and agent-aware optimization.Explore Air Router →
- AirGPUEfficient compute laneAirLLM-operated GPU capacity for selected routine workloads, backed by upstream fallback.Learn about AirGPU →
- Control PlaneGovernance and operationsBudgets, model policies, analytics, roles, SSO, billing, and live agent-session controls.Explore Control Plane →
- AlinaPlatform support agentIn-product help grounded in AirLLM documentation and available account context.Meet Alina →
- IntegrationsBring the tools you already useConnect supported coding agents and applications to the AirLLM runtime.View Integrations →
Who Enters Where
One platform. Three ways in.
Developers
- Start with
- AirCode or connect an existing coding tool.
- Get
- Task-aware routing, efficient model selection, caching, fallback, and loop protection.
Teams
- Start with
- Air Router + AirCode
- Get
- Shared AI infrastructure, budgets, model governance, usage visibility, and centralized spend.
Enterprise
- Start with
- Control Plane
- Get
- Organization-wide policies, SSO, roles, model governance, cost visibility, and live control of AirCode sessions.
Start with one layer. The platform becomes more context-aware as the layers work together.
AI infrastructure shouldn’t stop at the model response.
Connect the agent doing the work, the router choosing the intelligence, the compute running it, and the controls governing it.
Your task
AirCodeagent
Air Routerrouting
AirGPUFrontier Models
Outcome
- built
- tested
- verified
- stopped if looping
outcome signal ↺
Most AI infrastructure optimizes the model call. AirLLM optimizes the work around it.
Don’t optimize the token. Optimize the task.