Docs

What's new

• Jul 2026 · new model

  Kimi K3 (kimi-k3) — Moonshot's flagship, now routable

  2.8T params, up to 1M context, native visual understanding. In our agent-build benchmark it hit 8/8 with 5/5 UI polish — matching Opus, Fable, and GPT-5.6-sol — in the fewest iterations, at ~$3.60/build (half of Opus, a third of Fable). It's the cheapest 5/5 of the nine models tested — the new value leader of the top tier. See the benchmark →

Getting started

srooter exposes two universal endpoints — Anthropic-native at /anthropic/v1/messages and OpenAI-compatible at /v1/chat/completions. Point your existing tool at one of them and you get routing, budgets, policy, and an audit log for free — nothing else in your workflow changes.

Claude Code

ANTHROPIC_BASE_URL=https://api.srooter.ai/anthropic
ANTHROPIC_API_KEY=srt_xxx_yyy

Codex / aider / any OpenAI client

OPENAI_BASE_URL=https://api.srooter.ai/v1
OPENAI_API_KEY=srt_xxx_yyy

Get a key from the dashboard (OTP login auto-provisions your org). The in-app Getting started page has one-command srooterctl wiring for every tool.

srooter Studio — the desktop app

Prefer a native app to the CLI? srooter> Studio is a macOS app for the whole development loop through srooter — no environment changes, TDD + functional + visual validation by default, and a codebase the agent actually understands. Every request still runs through the gateway (routing, budgets, policy, audit). Signed & notarized · Apple Silicon + Intel.

Five surfaces, one window:

• Tasks — point at a project, describe what you want; an agent works it as a live chat, streaming its reasoning and asking permission before it acts. Run several in parallel (shared tree or isolated worktree).
• Knowledge — the cortex code graph + Mnemos session memory; auto-indexes on open so the agent starts oriented, not cold. Refresh the Agent Codemap here too.
• Council — five model seats grounded in real SDLC frameworks (SOLID, C4, OWASP, the Test Pyramid…) deliberate, surface where they disagree, and you can push back.
• Reviews — paste a GitHub PR link (or review your local diff) for a grounded council review.
• Routing — see which model each tier routes to and why (read-only; edit on the web dashboard).

New here? The Getting started guide walks through install + your first task.

The srooter-agent CLI

A first-party coding agent that runs through the gateway, so it inherits the same routing, budgets, policy, audit, and cortex. Install it with one command from any directory — like claude or codex. Needs Node 20+.

curl -fsSL https://api.srooter.ai/agent.sh | bash

Configure (flags → env → ~/.srooter/config)

export SROOTER_API_KEY=srt_…
export SROOTER_URL=https://api.srooter.ai
export SROOTER_MODEL=claude-opus      # optional
export SROOTER_PROJECT=acme/api       # optional: cortex project to ground in

Use

srooter-agent doctor                 # check gateway + key (no generation)
srooter-agent -- "summarize src/index.ts"   # one-shot, CI-friendly
srooter-agent                        # interactive REPL

Permissions: read-only tools always run; write/shell tools prompt for approval in the REPL ([y] once, [a] always, [n] deny). In non-interactive runs they are denied unless you pass --dangerously-allow-all.

Command reference

Slash commands (REPL)

Flags

Autonomy & orchestration

Ops, scheduling & workflows

srooter-agent monitor            # sessions, token totals, spend, scheduled count
srooter-agent schedule           # fire any due scheduled tasks once (cron tick)
srooter-agent schedule run       # foreground scheduler: tick every minute
srooter-agent workflow wf.json   # run a multi-step workflow

Cortex & review

Routing rules

srooter classifies every request into a tier and routes it to the model you've assigned. You never change your tool's model — srooter picks the right one per request. Defaults:

Change them in your dashboard at Routing: pick the model per tier, the intent-classifier model, the council members, and the long-context threshold. A live preview scores your config on speed / cost / quality and the blended $/1k tokens, with a baseline comparison against running one frontier model for everything. Changes apply to new requests; reset to srooter defaults anytime. Hard caps — model allowlists, max reasoning effort, speed tier — live under Policies.

Cortex code graph

Cortex is an iCPG (intelligent code property graph) — your org's knowledge of its own code: symbols, dependency edges, and intent pulled from docstrings. Once indexed, coding sessions can ask "where is X" and get answered from the graph, blast-radius is known, and risk reviews are grounded in real structure instead of guesses.

srooter cortex build .         # index this repo (project auto-detected)
srooterctl cortex .            # same, using your saved key + gateway
srooter cortex build . --force # force a re-index
srooterctl cortex-hook on      # auto-index on every Claude Code session
srooterctl doctor             # verify ("cortex auto-index: OK")

Browse it in your dashboard at Cortex — search across code / intent / memory, a clustered graph view, stats, and the intent nodes (goals, invariants, decisions) captured from your code.

Agent Codemap

A CODEMAP.md is a machine-first map an AI agent reads first to orient in a repo — what the system is, where things live, how a request flows, and the invariants not to break — instead of burning dozens of tool calls crawling the tree. Where AGENTS.md / CLAUDE.md give the agent the rules, the Codemap gives it the map. srooter generates it from your code graph so it stays fresh — and any agent (Claude Code, Codex, Cursor, Windsurf, OpenCode) reads the same format.

srooter cortex codemap .           # preview a fresh map (stdout)
srooter cortex codemap . --write   # write / refresh CODEMAP.md
srooter cortex codemap . --check   # validate anchors + freshness (exit 1 on error)
srooterctl codemap .               # same, using your saved key
# also: /codemap in the srooter-agent REPL · Studio -> Knowledge -> Refresh CODEMAP.md

The generator owns the deterministic sections (architecture, module map, danger zones) and drafts the rest with confidence markers for you to curate. --check gates writes and runs on session start, so a stale or broken map is caught — never silently trusted. See ADR-067.

Skills

Skills inject your engineering practices into the model, per intent. srooter ships four default skills:

Skill-aware routing also matches high-craft one-shot asks — a slide deck, dashboard, landing page, or polished doc — to a capability skill that injects a polished-artifact scaffold and can upgrade the model for that request. Define your own org-wide skills (name, directive, intents, soft / hard enforcement, priority) at Skills, and personal ones — layered on top of org policy, never overriding governance — at My skills.

Session memory

Mnemos is srooter's working memory per coding session. As you work it captures goals, constraints, errors, decisions, and result checkpoints — and consolidates them as the session gets long — so the model stays grounded in the session's actual state instead of thrashing on raw message history. It gives a long session a warm cold-start and recall across sessions.

Inspect it in your dashboard at Mnemos — sessions with their latest checkpoint (goal, active constraints, a fatigue score) and the typed nodes (Goal · Constraint · Error · Decision · Result).

Risk reviews

Risk reviews catch changes that touch sensitive surfaces — auth, tenant scoping, secrets. A fast guard model scores each change out-of-band; when the score is high, Opus validates the approach and injects a corrective nudge into the agent's next turn, so the session self-corrects before the code ships. Nothing blocks the developer — it steers.

Review events in your dashboard at Risk — each shows a severity, the findings (which dimensions fired, with evidence), the Opus nudge, and buttons to mark the outcome (confirmed / incident / dismissed / trivial) so the threshold tunes to your codebase.