Always online.Unlimited usage.One flat price.

standardcode.ai · 2026-08-04 · by Long Nguyen ·generic
Standard Code is a cloud-based coding agent with unlimited usage, built and operated by Standard Agents. $5 for your first week, then $49/month per line.

Always online.Unlimited usage.One flat price.

The how

How is unlimited usage possible?

Standard Code is able to offer unlimited usage because of its unique lines-of-service billing model and a novel, curated agent architecture.

01 · Lines of service

One active session per line

Each active Standard Code session occupies a line of service on your plan. Lines of service can be added to your plan at any time if you require additional parallel sessions.

02 · Concurrency, not tokens

Each line is unlimited

For each active line of service on your plan, you can run a Standard Code session with unlimited usage. Usage is constrained by linear time, not token quota.

03 · Preconfigured sub-agents

Standard Code is a swarm of agents

Standard Code is made up of a pre-configured, finely-tuned team of expert agents. Each is automatically invoked as needed, and sub-agents do not count against your active lines of service.

04 · Composable agent architecture

Sub-agents are full agents

Every sub-agent is a specialized domain-specific agent with its own curated prompts, tools, and context. This allows us to tune the agents that make up Standard Code for maximum efficacy per dollar.

Lines of service−+$294/ mo6 × $49/line

Stop configuring, start building

Two curated cloud agents

built for real-world work.

standardcode · \~/app

Standard Code v0.11.6

terminal coding agent

\~/projects/app

Standard Code — Unlimited One

project: \~/projects/app

machine: Mac-Studio.local thread: e7c80ca8

tool execution: this terminal

❯ migrate our REST layer to tRPC, update every call site, and keep the tests green

✓ code\_explorer\_agent · 214 files mapped

✓ research\_agent · findings delivered

✓ edit src/server/router.ts

✓ edit src/api/client.ts (+412 −380)

✓ update 37 call sites across 22 files

⣽ compaction\_agent compacting context while work continues

✓edit the server and client files

✓update dependent call sites

▸run the test suite

⣽ Working bash: pnpm test · ↑41.2k ↓0.6k · ctx 31%

Unlimited One

❯

session 1 of 1unlimited usage

  • CLI
  • API
  • Web app
  • macOS app
  • iOS app

    • Always-on cloud coding agent

    Unlimited One

    Standard Code's default agent leveraging open weight models. The world's first curated coding agent — powered by a coordinating team of domain-specific agents.

  • A curated collection of domain-specific agents working in concert
  • Unlimited usage per active session
  • Sessions run in the cloud and can be resumed from any connected machine
  • Flat, predictable billing per line of service

    • Always-on cloud coding agent

    Sama One

    Standard Code's same domain-specific agent architecture powered by OpenAI models. Uses your existing ChatGPT Pro subscription.

  • The same novel domain-specific agent architecture
  • Uses your existing Codex token quotas
  • Sessions run in the cloud and can be resumed from any connected machine
  • Does not occupy available lines from your Standard Code plan

    • Requires at least one active line of service.

    Learn more about using Standard Code with OpenAI models →

    provision.ts — northstar-web

    provision.tsstream.tswebhook.ts

    1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26

    const BASE = "https://api.standardcode.ai";
const KEY = process.env.STANDARDCODE_KEY!;
const auth = { Authorization: `Bearer ${KEY}`, "Content-Type": "application/json" };
    // one thread per job, resumable from any client
const { threadId } = await fetch(`${BASE}/api/threads`, {
  method: "POST",
  headers: auth,
  body: JSON.stringify({ agent_id: "standard_code_agent", tags: ["ci"] }),
}).then((r) => r.json());
    // sending a user message starts the agent's turn
await fetch(`${BASE}/api/threads/${threadId}/messages`, {
  method: "POST",
  headers: auth,
  body: JSON.stringify({ role: "user", content: "Rate-limit the upload route." }),
});
    // watch it work
const ws = new WebSocket(
  `${BASE.replace("https", "wss")}/api/threads/${threadId}/stream?token=${KEY}`,
);
ws.onmessage = (e) => {
  const f = JSON.parse(e.data);
  if (f.type === "message_chunk") process.stdout.write(f.chunk);
};

    TypeScriptLn 26, Col 3 · UTF-8 · LF

    The Standard Agents architecture

  • CLI
  • API
  • Web app
  • macOS app
  • iOS app

    • Every client connects

    to the same cloud sessions.

    How does it work? Take a look behind the scenes

    standardcode · \~/app

    Standard Code v0.11.6

    terminal coding agent

    \~/projects/app

    Standard Code — Unlimited One

    project: \~/projects/app

    machine: Mac-Studio.local thread: e7c80ca8

    tool execution: this terminal

    ❯ migrate our REST layer to tRPC, update every call site, and keep the tests green

    ✓ code\_explorer\_agent · 214 files mapped

    ✓ research\_agent · findings delivered

    ✓ edit src/server/router.ts

    ✓ edit src/api/client.ts (+412 −380)

    ✓ update 37 call sites across 22 files

    ⣽ compaction\_agent compacting context while work continues

    ✓edit the server and client files

    ✓update dependent call sites

    ▸run the test suite

    ⣽ Working bash: pnpm test · ↑41.2k ↓0.6k · ctx 31%

    Unlimited One

    ❯

    session 1 of 1unlimited usage

    Standard Code is

    always online.

    01

    Session state lives

    in the cloud.

    Sessions executing on an always-on machine, such as a VPS, can continue uninterrupted even if the client you're using to drive the session disconnects.

    02

    Every client connects

    to the same sessions.

    Standard Code ships with first-party native clients for your terminal, the web, macOS, and iOS.

    Thread history, queued messages, and even unsent drafts stay synchronized.

    03

    Every session has

    a full API.

    Standard Code exposes the same REST and WebSocket APIs its own clients use. Drive sessions from CI, internal dashboards, or your own product.

    Read the API docs

    REST

    Drive it from code

    Create, message, list, and resume sessions from any language over plain HTTP. No SDK required.

    `POST /threads · GET /threads/:id`

    WEBSOCKET

    Watch it live

    Stream tokens, tool steps, and the end-of-turn signal as they happen.

    `⇅ wss://your-instance/threads/:id/ws`

    ACCESS KEYS

    Hands-off loops

    Use a bearer token to run jobs from a push or a schedule.

    `Authorization: Bearer sk_standard_…`

    Standard Code knows

    how to get work done.

    0/5STEPS

    elapsed 0m

    ◇ goal 0/5 ship dark mode

    Audit theme tokens6m

    Define dark palette9m

    Build the theme toggle4m

    Migrate 41 components18m

    Run visual regression11m

    ✓ goal complete · 48m

    ✓ assets/mark.png · saved to your project

    04

    Big asks,

    little tasks.

    Give Standard Code an outcome. It sets a goal, breaks it into steps, and checks each one off. Unlimited usage keeps it working until the goal is complete.

    05

    Every specialist owns

    its own context.

    Standard Code dispatches subagents for research, codebase exploration, asset creation, and more. Subagent work never crowds your session's context.

    06

    Thread compaction

    is non-blocking.

    Standard Code uses a dedicated subagent to compact long-running threads. Compaction happens in flight and never pauses your session's work.

    07

    Batteries (and

    asset generation) included.

    Ask for an icon, a hero image, a sprite sheet. The asset subagent creates it, runs its own QA, and places the file into your project.

    Also in the box

    SKILLS & MCP

    Bring your own tools

    Install Agent Skills that persist across sessions and connect any MCP server.

    FAILOVER

    Sessions stay online

    When a model provider fails, the session moves to another one mid-run and keeps its thread intact.

    PERMISSIONS

    Your machines stay yours

    Per-tool permission gates mean the agent only ever touches what you allow.

    APPROVALS

    Approve from anywhere

    Permission prompts follow you to whichever client you are watching, so a waiting session never blocks the machine running it.

    Try Standard Code

    for five dollars.

    Your first week

    $5then $49/month

    Renews at $49/month after 7 days for one line of service. Cancel anytime.

  • Unlimited usage
  • Automatic subagents
  • Resumable cloud sessions
  • Official first-party clients
  • Programmable API
  • Add additional lines anytime
  • Unlimited One
  • Sama One
Start your $5 1-week trial

Additional lines available, $49/month each · Secure checkout by Stripe

For enterprise

Get Standard Code for your entire organization.

on our infrastructure

Organization-wide plan

Hosted seats billed centrally: headcount × $49, unlimited usage.

or

on your infrastructure

Full-stack license

The entire Standard Code stack on your infrastructure with your inference providers and visibility into usage through the Standard Code admin panel.

Standard Code for enterprise →

Early access

Join the Standard Code

early access waitlist.

Join the waitlist. We'll send you a key when it's your turn.

Request early access

Already have a key? Start your $5 week →

Questions while you wait? Join us on Discord →

standardcode.ai · 4 images · 10 links

Comments (0)

No comments yet