qredits is QitQode's built-in usage balance. You can check it at any time from inside the CLI, so usage is inspectable as you work — not a surprise at month-end.

Does QitQode work over SSH?

Yes. Sign-in uses a device-code flow that works everywhere, including SSH sessions, containers, and remote sandboxes: the CLI shows a verification URL and code, and you approve on any device to finish.

Is QitQode open source?

Yes. The source code is licensed under the plain MIT License — no separate use-restrictions file and no service terms buried in the tail of the README.

› resuming session — memory injected, context rebuilt

Terminal AI Agent

The coding agent that remembers.

QitQode reads and writes code, runs commands, manages Git — and keeps a persistent, searchable memory of your project across sessions, rebuilding its own context when it runs long so it can keep working instead of starting over. Turn repeated processes into reusable sequences with start, progress, and continue/stop controls. Get code feedback as you edit. Work from Android terminals. Bring your project tools together — terminal, search, browser preview, reusable instructions. Choose the AI service that fits your project.

Install now Read the docs

Why QitQode

Built around four mechanisms

You don't need another chat wrapper. You need an agent that can hold a long-running job without losing the plot.

01 · Memory

Memory that survives the session

Every project gets a persistent memory layer backed by SQLite full-text search. When you resume, the relevant memory is injected automatically — ranked and token-budgeted, not dumped. Search saved project notes and previous conversations to revisit decisions and keep unfinished tasks in view.

Project knowledge in MEMORY.md
Automatic session checkpoints
Scratch notes and per-task progress logs
Searchable project notes and conversation history

02 · Context

Context that rebuilds itself

Long tasks blow past context windows. QitQode watches the window, checkpoints state before it fills, and reconstructs working context — so a multi-hour refactor doesn't die at the token limit.

Automatic, window-aware checkpoints
Reconstruction from checkpoint, memory, and task progress
Token-budgeted, importance-ranked injection

03 · Autonomy

Autonomy you can hold accountable

Set a stopping condition with /goal. When the agent thinks it's done, an independent judge model reviews the conversation and decides whether the goal is actually met — no more optimistic "all done!" halfway through. Get code feedback as you edit, helping you spot issues and review changes as you work. /goal tracks an objective; a named sequence repeats a multi-step process. Set up a named sequence of agents and tools, start it when you need it, follow its progress, and continue or stop the run as your work changes. Recorded results can be used again in the workflow.

Independent judge model on /goal
Tree-shaped task tracker (T1, T1.1, …)
Parallel subagents for real unattended work
Explicit goals and progress tracking
In-editor code feedback while you edit
Named multi-step agent/tool sequences
Start, progress, continue/stop controls
Reusable results across runs

04 · Subscription

One subscription, zero provider plumbing

Eight tiers, one sign-in. No provider dashboards, no API-key juggling, no per-model billing spreadsheets. Usage is inspectable, not a surprise at month-end. A project's AI-service choice is separate from its tier setting, so you can connect the service that fits the work without disturbing the tier you are running.

Switch tiers mid-session with a slash command
Built-in qredits balance display
Device-code sign-in that works over SSH
AI-service choice separate from tier setting

Quick Start

Install in one command

The main QitQode CLI package is @qitqode/cli. Install it globally with npm or Bun, then run qitqode in any project.

npm

npm install -g @qitqode/cli

Bun

bun add --global @qitqode/cli

Prerequisites

Node.js >= 20 for the published CLI; npm or Bun to install it.
@qitqode/cli has seven optional native packages: Linux (arm64/x64), macOS (arm64/x64), Windows (arm64/x64), and Android (arm64).
Musl Linux uses the separate @qitqode/cli-musl package with two optional native packages (arm64/x64); it is not included in the main package.
Android arm64 is a published, installable target; this does not establish a broader Android support commitment or SLA.
Run QitQode in the Termux terminal app for Android to bring terminal-based project work with you.
Building from workspace source separately requires Bun >= 1.3.11; that is not the published CLI's Node runtime requirement.

First launch

Run qitqode. The first launch guides you through sign-in:

Sign in with QitQode — a device-code flow that works everywhere, including SSH sessions and remote sandboxes: the CLI shows a verification URL and code (and opens your browser when one is available); approve on any device to finish.
API key — paste a QitQode API key instead.

Then pick a tier from the model selector and start working. That's the whole setup.

Model Tiers

Eight tiers, one sign-in

Switch tiers mid-session with a slash command. Every tier is included in the same QitQode account — no separate provider accounts, ever. Earlier default and power tiers are retired; requests for them are rejected rather than silently remapped.

QitQode model tiers and their switch commands
Tier	Switch command	Description
Free	`/free`	Get started at no cost — try the full agent workflow before subscribing.
Fast	`/fast`	Lower latency for quick edits, rapid iteration, and interactive back-and-forth.
Economy	`/economical`	Stretch your qredits on long or routine tasks where cost matters most.
Adaptive	`/adaptive`	Balanced quality and speed for everyday work when you have no special constraints.
Planner	`/planner`	Deep planning and decomposition for turning complex goals into clear, actionable work.
Repair	`/repair`	High-quality correction and refinement for validating, fixing, and improving existing work.
Max intelligence	`/max-int`	Maximum capability for the hardest problems — deep refactors and complex debugging.
Orchestrated	`/orchestrated`	Multi-stage pipeline — gate, plan, parallel build, and repair handled automatically.

FAQ

Common questions

Does it need individual API keys?

No. One account covers all eight model tiers — free, fast, economical, adaptive, planner, repair, max-int, and orchestrated. There are no provider dashboards, no API-key juggling, and no per-model billing spreadsheets. Sign in with the device-code flow or paste a single QitQode API key.

What are Qredits?

Qredits are QitQode's built-in usage balance. Check it any time from inside the CLI — usage is inspectable as you work, not a surprise at month-end.

Does it work over SSH?

Yes. Sign-in uses a device-code flow built for real machines: it works over SSH, in containers, and in remote sandboxes where a loopback browser redirect never could. The CLI shows a verification URL and code; approve on any device to finish.

Is it open source?

Yes. The source code is licensed under the plain MIT License — no separate use-restrictions file, no service terms buried in the tail of the README.

What is the /goal command?

/goal sets a stopping condition for a session. When the agent tries to stop, an independent judge model evaluates the conversation to decide whether the condition is truly satisfied — preventing premature "optimistic stops" during autonomous work.