Chariot

// The Platform

One platform to run, train, and command a fleet of agents.

Chariot is the infrastructure for consumer-scale AI agents — a sealed always-on runtime, a real-environment training center, and a fleet command center. One private agent per user, at any scale.

Powering production agents atA‑LIST
SOC 2 TYPE IIHIPAA
// The shift

Your customers don't want a chatbot they have to manage. They want an agent that's always there, acts on their behalf, and never leaks. Chariot is the infrastructure to run a fleet of any size — from one agent to millions — trained, operated, and supervised.

// 01 / Always-On Runtime

Always on. Always private.
Always affordable.

Every agent runs in its own sealed, persistent VPS — a real computer with a filesystem, shell, tools, and memory, holding exactly the org context it needs and no more. A consumer never debugs or calls support; the machine is just always there.

A real computer per user — files, processes, and a network identity that persist between sessions.
Sub-second, always-on responsiveness — the machine is always there, no cold starts.
Hard per-user isolation — one agent's VPS can never reach another user's data.
runtime/vps.policy
sealed
VPS
Sealed VPS
its own filesystem, shell, tools & memory
App-controlled access inALLOWED
Public ingress✕ BLOCKED
Outbound internet & toolsGATED
Agent → agent data flow⊘ ISOLATED
// 02 / Training Center

Train on your scenarios.
In your real environment.

This is the engine behind the payoff. Define the scenarios that matter to you and run them in the real runtime your agents actually operate in — live tools, data, and modules, not an LLM-only sandbox. Prove a change here and you can ship a cheaper model or a leaner runtime without ever risking quality.

Train on the scenarios you define — the situations your agents actually hit.
Runs in the real environment: live tools, data, and runtime modules — never LLM-only evals.
Pull every lever — Skill.md, data source (MCP), runtime modules, model — then ship the cheaper one with quality proven.
training/scenarios.eval
31 defined
31
scenarios you define — real-environment runs, not LLM-only evals
Levers
skillsSkill.md × 14
data sourceMCP server
runtime modules6 enabled
modelSonnet GLM
// 03 / Command Center

You're not deploying agents.
You're running a workforce.

Push commands, fixes, overrides, and broadcasts across the whole fleet — one agent or millions — from one console. Watch health, wedged sessions, and drift — and survive thundering herds, contention, and rolling updates.

Deploy a fix to one agent or the entire fleet at once.
Live health, override, and broadcast controls.
Built to survive global incidents without paging a human.
command/fleet.live
live
agents
2,140 · 99.1%
>push patch v2.4 → all agentsDEPLOY
// Elasticity

Persistent VPS. Elastic compute.

Each agent is a persistent VPS — a durable disk, identity, config, and permissions that are always there, even when nothing is running. Compute attaches to the VPS only when work arrives — chat, webhook, schedule, or API — runs the task, records the outcome, and detaches when idle. The machine persists; the compute is elastic.

agent ~ lifecycle
wake · run · hibernate
the VPS — durable, outside the running process
identityfilesystemmemoryconfigpermissionstask history
Work arrives
chat · webhook · schedule · API
Wake
attach compute to the agent's VPS
Run
execute with full context
Record
outcome → task history
Hibernate
compute released until next call

Work-oriented, not capacity-oriented.

No box reserved for every private agent. Chariot pools compute across mostly-idle agents and keeps pushing infrastructure and inference cost down through sleep/wake, routing, and eval-backed optimization.

Compute pools across mostly-idle agents — nothing reserved per agent.
Billed for work done, not capacity held.
Cost measured per active task, per minute, and per successful outcome.
cost / active taskcost / active minutecost / outcome
// The loop

Better and cheaper, every cycle.

Define your real scenarios, run them in the live environment, then swap in a cheaper model, a leaner runtime, or a tighter data scope. If quality holds — and it keeps climbing — you ship. Every turn of the loop drives cost down without ever shipping a worse agent.

01
Define
the real scenarios that matter to you
02
Run
them in the live runtime — real tools & data
03
Swap
a model, runtime module, or data scope
04
Prove
quality holds — or climbs
05
Ship
the cheaper build to the fleet

↻ and repeat — quality compounds, cost collapses, every cycle.

// each turn of the loop, proven before it ships
Opus → Sonnet
$115 → $60quality +2.6
Resource tuning
$60 → $42quality +1.1
Activity tuning
$42 → $11.86quality +2.9
GLM → Minimax M3
$8.91 → $2.84quality +1.5
“It's like /goal for making your agent continuously improve on every dimension.”
— Nathan S. · early customer
// Quickstart

What that one line gets you.

No SDK to wire up, no orchestration to stand up. Point Chariot at your endpoint and it provisions the fleet, opens a two-way channel to your backend, and hands you a live dashboard — instantly.

An agent for every user
Each user gets a private agent with durable identity, memory, and config — ready the instant they need it, with no per-agent setup.
Your backend, connected
Every agent talks to and listens at your endpoint from line one — fully bidirectional, no glue code.
A live dashboard
Watch status and activity for the whole fleet in the Command Center, spun up by the same command.
// Security & privacy

Private by architecture, not by policy.

SOC 2 TYPE IIHIPAA
Per-user isolation
Each agent is sealed. No agent can reach another user's data, by any path.
Scoped access
Exactly the context, skills, and tools an agent needs — and nothing more.
No public ingress
Workspaces accept only app-controlled access; outbound is gated and logged.
Full audit trail
Every action an agent takes is observable and replayable in the Training Center.

Better agents, for less. Every week.

See Chariot train, operate, and supervise a private agent for every user — on your data, with your tools — while cost falls and quality climbs.