Skip to content

Steerable

◆ The model-quality layer for local & cheap models ◆

Fewer hallucinations Smallest code Ready out of the box Componentized

79.0% on Terminal-Bench 2.1 with GLM-5.3-Flash. One command boots the full shell, or adopt any layer standalone.

Get started · Storybook · ★ Star on GitHub

GitHub stars License: Apache 2.0 npm: @steerable/agent-protocol npm: @steerable/agent-ui PyPI: steerable-agent-runtime PyPI: steerable-sidecar

79.0% Steerable + GLM-5.3-Flash TB 2.1 · this repo

+23.6 vs Codex on the same GLM Codex + GLM-5.3-Flash · 56.2%

229.9M input tokens per catalog run three-run mean · 15.4% below prior baseline

01 · Quick start

One command, full agent

Chat, terminal, sandboxed sidecar, and any OpenAI-compat, Anthropic, or Gemini key — across browser, desktop, and CLI.

Embed a layer ↓
git clone https://github.com/pathlyapp/steerable.git
cd steerable && pnpm install
pnpm agent-shell:web
→ Steerable Shell listening at http://127.0.0.1:4787
# in your product repo, with src-tauri wired to the shell crate
pnpm tauri dev
→ native window on the same host runtime and sidecar
npm install -g @steerable/agent-cli
steerable-cli login
steerable-cli run "summarize this repo"
→ one install brings the runtime; login verifies the key; Node 22.19 or newer (the terminal session needs 26.4)

Easy to integrate

Embed only the layer you need — a Python agent, React chat UI, or a Node.js agent. UI-only showcase: pnpm shell:dev.

uv add steerable-agent-protocol steerable-agent-harness steerable-agent-runtime
from steerable_agent_runtime import ToolRouter, tool
from steerable_agent_protocol import ToolCall

router = ToolRouter()

@tool(router=router, description="Read a file by path")
async def read_file(path: str) -> dict:
    return {"path": path, "content": open(path).read()}

result = await router.dispatch(
    ToolCall(id="c1", name="read_file", arguments={"path": "README.md"})
)
# result.success, result.data, result.error — all typed.
pnpm add @steerable/agent-protocol @steerable/agent-ui
import { ChatPanel, useChatStream } from '@steerable/agent-ui';

export function Chat() {
  const { messages, send, isStreaming } = useChatStream({
    endpoint: '/api/chats/123/send',
  });
  return <ChatPanel messages={messages} onSubmit={send} isStreaming={isStreaming} />;
}
# Bundle the sidecar binary into resources/python-runtime/<platform>/
pnpm add @steerable/agent-runtime
import { AgentRuntime } from '@steerable/agent-runtime';

const runtime = new AgentRuntime({ sidecarPath });
await runtime.start();   // spawn + lifecycle.ready handshake

const stream = await runtime.chatStream({
  provider: 'openai_compat',
  model: 'glm-5.3-flash',
  baseUrl: process.env.GATEWAY_BASE_URL!,
  apiKey: process.env.GATEWAY_API_KEY!,
  messages: [{ role: 'user', content: 'hi' }],
});
for await (const event of stream.events) { /* typed SSEEvent stream */ }
◆ ONE LOOP · TWO DEPLOYMENT FORMS ◆
Desktop & Terminal Tauri Desktop / CLI & TUI CoreLoop Server FastAPI SSE / Python ◆ SAME LOOP · DUAL DEPLOYMENT · TYPED PROTOCOL ◆

One Rust CoreLoop drives both the desktop sidecar (stdio JSON-RPC) and the FastAPI server (SSE) over LoopEvent.

Core mechanisms

Built for imperfect models — deterministic tool recovery, grounding vetoes, and fail-closed confinement.

01 · Fewer hallucinations

Grounded, not guessed

Grounding judges, completion vetoes, and automatic recovery for malformed text tool calls.

02 · Smallest code

Built for vibe coding

The smallest code surface. Plain @tool functions, no graph DSL.

03 · Ready out of the box

Fail-closed by default

Seatbelt / bwrap / Windows confinement, 61-rule classifier, and egress proxy. Try the keyless live demo.

04 · Componentized

Take one layer, skip the rest

5 tiers, 15 packages, strict no-upward-imports. Adopt just the protocol, UI, or sidecar.

Architecture

Strict no-upward-imports rule — adopt any tier and inherit only what sits below it. Architecture spec

◆ FIVE TIERS · NO UPWARD IMPORTS ◆
renders with supervises host bridge wire types embeds embeds validates validates imports TIER 5 Host Shell & CLI @steerable/agent-shell · agent-shell-tauri · agent-shell-web · agent-cli · pack-sdk Tauri desktop window · Node host runtime · headless HTTP server · CLI/TUI TIER 4 React UI @steerable/agent-ui 7 components · 14 cards · 3 hooks TIER 3 Sidecar steerable-sidecar Portable CPython · 38 RPC methods TIER 3 Runtime steerable-agent-runtime CoreLoop · 4 providers · ToolRouter TIER 2 Harness steerable-agent-harness · @steerable/agent-harness Pure-function policy · budget · retry · grounding · safety TIER 1 Protocol @steerable/agent-protocol · steerable-agent-protocol Single JSON Schema → generated TS/Zod + Pydantic wire types · lockstep X.Y.Z

Click any tier to highlight its downward dependencies — no layer ever imports above itself.

Package Tier What you get
@steerable/agent-protocol · steerable-agent-protocol 1 SSEEvent, ToolCall / ToolResult, ChatMessage, Sidecar JSON-RPC types (codegen from spec/)
@steerable/agent-harness · steerable-agent-harness 2 decide_tool_mode, consume_budget, next_retry_delay_ms, command-safety patterns
steerable-agent-runtime · @steerable/agent-runtime 3 CoreLoop, 4-protocol LLMProvider, @tool, ToolRouter, SSE/stdio transports & sidecar lifecycle
steerable-sidecar · steerable-egress-proxy 3 Portable CPython (<1s boot, signed & notarised) plus per-host CONNECT egress allow-list proxy
@steerable/agent-ui 4 7 core components (ChatPanel, MessageList, ToolCallRenderer, …) + 14 /cards + hooks + Tailwind preset
@steerable/agent-shell · agent-shell-web · agent-shell-tauri · pack-sdk 5 Tauri + headless host shell, shared Node HostRuntime, sidecar supervision, product-neutral renderer
@steerable/agent-cli · @steerable/runtime-<target> 5 CLI & TUI (steerable-cli login), auto-pulling the platform runtime and sharing the host DB

How common frameworks compare

Terminal-Bench 2.1 (89 tasks). 79.0% is GLM-5.3-Flash @max (3-run mean); charts compare single n=1 runs. Methodology

Pass rate · three Flash models · five harnesses

Tasks solved out of 89. Hover any bar or filter above.

0 25 50 75 89 79.8 73.0 77.5 56.2 66.3 GLM @high 78.7 69.7 44.9 61.8 77.5 DS0731 @high 68.5 62.9 70.8 64.0 60.7 Qwen @medium Steerable P* C* C* C* D* H*

One run per cell at high effort (Qwen: medium). Run list and commit SHAs

Score vs cost per solved task

Shape is model (circle GLM, square DeepSeek, diamond Qwen). Higher and further left is better.

$0.10 $0.25 $0.50 $1 $2 $5 45 55 65 75 80 $ per solved task (log) · OpenRouter list on pinned host TB 2.1 score (n=1 pass / 89) P* · GLM 73.0% · $0.12 C* C* · GLM 77.5% · $0.23 P* · DS 69.7% · $0.28 Steerable · GLM 79.8% · $0.61 C* C* · DS 44.9% · $0.85 C* · GLM 56.2% · $1.06 C* C* · Qwen 70.8% · $1.68 Steerable · DS 78.7% · $2.18 C* · Qwen 64.0% · $2.60 P* · Qwen 62.9% · $2.87 Steerable · Qwen 68.5% · $4.12 C* · DS 61.8% · $4.42 D* H* · GLM 66.3% · $0.12 D* H* · DS 77.5% · $3.48 D* H* · Qwen 60.7% · $3.36 Steerable P* C* C* C* D* H* circle GLM · square DeepSeek · diamond Qwen

OpenRouter list prices on the pinned host. Pricing formula

GLM-5.3-Flash @high (n=1): Steerable 79.8% · C* C* 77.5% · P* 73.0% · D* H* 66.3% · C* 56.2%.

Beyond pass rates — how Steerable compares on runtime form, loop events, sandbox, and model recovery:

Dimension Steerable OpenAI Codex DeepSeek Harness LangGraph OpenAI Agents SDK Claude Code / Agent SDK
What you get 5 modular tiers: signed desktop sidecar + FastAPI server + 14-card React UI over one wire protocol Closed product family (CLI / IDE / cloud), not an embeddable UI/SDK stack Plugin-based TS harness (Cordis) for CLI/Web; no standalone desktop sidecar State-graph orchestration only; no built-in UI, sandbox, or desktop runtime Server-side orchestration only; no desktop sidecar or React UI kit Closed-source CLI + SDK bundle; cannot adopt individual layers
Cheap & local models Built-in recovery: parses malformed text tool calls + grounding judge + completion veto (79.0% on Flash) Assumes structured tool_calls Assumes structured tool_calls No built-in recovery — you own the loop and checks Built for frontier models Built for frontier Claude models
Model lock-in Zero lock-in: OpenAI-compat (Ollama/vLLM), Responses, Anthropic, Gemini natively Centered on Responses wire & OpenAI Multi-model (focused on DeepSeek / standard wires) Multi-model via your own SDK calls Tied to OpenAI (other providers via LiteLLM) Anthropic models only (via 8 backends)
Default sandbox & egress Fail-closed by default: Seatbelt / bwrap / Windows + 61 rules + per-host CONNECT allow-list Platform sandbox + approvals + managed proxy sandbox.confine (fail-closed) None built-in (bring Docker / cloud sandbox) Docker or hosted Sandbox Agents (no local Linux confinement) CLI defaults fail-open (missing backend warns and proceeds)
TS + Python contract Single JSON Schema codegen → TS/Zod + Pydantic, 15 lockstep packages + golden conformance tests Generates TS types; separate SDK implementations TS-first; Python SDK bridges via CLI/RPC Separate Py / JS libraries; no shared schema codegen Separate Py / TS libraries; no cross-language codegen Publishes TS declarations only (sdk-tools.d.ts)
Trade-off Native CoreLoop engine is closed-binary; early ecosystem (0.12.x) Huge real-world mileage, but monolithic product stack Open-source, still public prerelease (0.2.x) Mature ecosystem, but loop guards & UI are DIY Quick to start, lacks desktop & cross-tier plumbing Feature-rich, but closed-source and Anthropic-only

Trade-offs and when to pick which: Full comparison.

Who's using it

Production desktop shells and enterprise deployments.

Explore

Try Steerable Launch the keyless browser demo or read the architecture guide.