built on the axon runtime

The coding agent that lives
in your terminal.

cortex streams the model, dispatches tools, persists an append-only session, and prunes its own context under pressure — then gets out of your way. No Electron. No browser tab. Just a transcript you can scroll, search and copy.

Get started →View on GitHub

session started · openrouter/deepseek-v3.2 · pruner on

turn 1 started

❯ add a spinner to the waiting state

turn 1 · calling model...

▐ read internal/ui/view.go

│ // waiting is what the user sees between submitting and first output.

│ func (m Model) waiting() string {

└ ✓ 3 lines

▐ read internal/ui/theme.go

└ ✓ 68 lines

▐ write internal/ui/view.go save

└ ✓ ok

▐ exec go test ./internal/ui/...

│ ok github.com/atakang7/cortex/internal/ui 0.31s

└ ✓ 1 line

Added a MiniDot spinner to waiting(). It ticks on the

turn goroutine and stops on first output.

turn 1 ended

deepseek-v3.2 · pruner: llama-3.1-8b · cortex/internal/ui · turn 1 · ctx 12040 · tokens 12040↑ 340↓

❯

why cortex

A loop, a product, and a terminal.

axon ships the loop. cortex ships the product on top — the config, the role text, and the terminal it talks through. Everything layers one direction.

⌘

Committed scrollback

The transcript writes to your terminal's own scrollback — not an alternate screen. A finished session stays scrollable, searchable and copyable, even after cortex exits.

✂

Self-pruning context

A cheap secondary model parks stale context so the main model stays under its window. Old blocks are summarized, not dropped — you keep the thread without paying for it twice.

⟳

Append-only sessions

Every turn is persisted as it happens. Undo a file edit byte for byte, resume a session, or audit exactly what the agent did and when.

🔌

MCP, auto-discovered

Spawn any Model Context Protocol server at startup and its tools are wired in automatically — GitHub, filesystems, databases, anything that speaks MCP.

⌗

Composable non-interactive mode

--prompt writes the answer to stdout and everything else to stderr, so cortex pipes cleanly into scripts: cortex --prompt "…" > out.txt

🔭

Wire-level traces

Every request and reply is logged to a trace file — the composed system prompt, the windowed conversation, the pruner's curator calls. Prompt-engineer against reality.

how it works

One turn, four moves.

cortex plans, reads, edits and verifies — then stops. The loop is deliberately tight: a turn that ends with only a plan has produced nothing.

🗺️

Plan

State the shape of the work before it's expensive to change your mind.

📖

Read

Search before you read, read before you write. No guessing paths.

✏️

Edit

Change files in place. Atomic, recorded, revertable byte for byte.

✅

Verify

Run the thing that proves it — the test, the build, the command.

Config that layers, not sprawls.

Three sources, each overriding the last. Your user config holds defaults, a project config overrides per-repo, and the environment overrides both — field by field.

✓ A project config that names only a model keeps the API key from your user config.
✓ Known providers supply a default base_url automatically.
✓ A $-prefixed api_key reads straight from the environment.
✓ One shared providers.json across every axon-family tool.

# ~/.config/cortex/config.yaml
name: reviewer

provider: openrouter
model: deepseek/deepseek-v3.2

pruner:
  model: meta-llama/llama-3.1-8b

mcp_servers:
  github:
    command: docker
    args: ["run", "-i", "--rm",
           "ghcr.io/github/github-mcp-server"]
    env: ["GITHUB_TOKEN=…"]

The coding agent that livesin your terminal.

A loop, a product, and a terminal.

One turn, four moves.

Config that layers, not sprawls.

Ship edits, not prompts.

The coding agent that lives
in your terminal.