Terminal

albertcode is AlbertCode in your terminal: a full-screen interface on the same sessions as the browser workspace, the classic terminal for one conversation printed as it goes, and a subcommand for every step so you can script it. This page lists every command.

Start it

cd your-project
albertcode

AlbertCode works on the folder you start it in. The first run starts the background service and, with no model connected, opens Connect a provider for you (press Esc to skip). Then type in the box at the bottom: a question, a change, or a /command.

The full-screen interface needs a real terminal. Piped, on an AlbertCode service your organisation runs (--url), or with ALBERTCODE_CLASSIC=1, albertcode opens the classic terminal instead.

Options

The terminal interface

 █████ █     ████  █████ ████  █████  ████  ███  ████  █████     (the name in solid letters)
 AlbertCode SWE Agent · Two human gates
 folder  ~/code/shop        model  gpt-5        mcp  1 connected

 Show the prices in euros
 ▸ 3 steps before answering
 Prices are kept in cents in cart.py …

 shop · gpt-5 · governed ❯ Add a 10% discount code for first orders
                                              tab modes · ctrl+p commands · ctrl+x h help ●

• The conversation scrolls above the box: your messages, Albert's answers, and each task as it goes, with Albert's steps under it: what he read, wrote and ran, a stage at a time. Ctrl X then O shows every step, or folds them again.
• The prompt says the folder, the model and the mode before ❯. Tab moves to the next mode: governed, direct (asking before each write, or auto-approving) and ask only.
• A gate (a plan, a write, a change to accept) is a question in place of the box: the arrows choose an answer and Enter gives it, or its letter does: a approve or apply, e revise, r reject, x discard, v the diff, d the whole plan; for a write, A allow the rest and n decline. Esc goes between the gate and the box.
• Lists open under the conversation in place of the box: type to filter, the arrows to move, Enter to choose, Esc to close. Some rows have keys of their own, said under the list.
• @ in the box finds a file of the repository to name; / lists the commands.

The sessions are the browser workspace's too: a session started in one is there in the other, and what Albert does shows in both as it happens.

Commands in the terminal interface

Anything else starting with / is one of this repository's custom commands, or /server:prompt key=value …, an MCP server's prompt filled in and put in the box to edit and send. A repository's own /requirements or /architecture takes the place of AlbertCode's, since those names are not reserved.

AlbertCode's own screens

Each opens as a list under the conversation, with the facts it is about above it.

Tasks. /tasks lists every task under Waiting for you, Working, Failed, Done and Closed, with where each stands, its repository and when it started. Enter opens one: its request, plan, changed files and checks, and, when no session holds it, the answers its gate takes: Approve and build or Reject the plan; Allow this write, Allow the rest or Decline this write; Accept into your files or Discard the change. Open its session, Its change and Its evidence go further. Ctrl L opens a task's evidence from the list. /tasks clear deletes the history of every task that is not running, once you type delete; the ledger keeps its record of each.

/tasks
  Tasks
  WAITING FOR YOU
› Let customers order a loaf for tomorrow   Plan waiting for you · Governed · just now
  DONE
  Add a loaves endpoint test                Applied · Governed · 2h ago

Evidence ledger. /ledger lists every governed action, newest first, under whether the chain holds. Type to find an entry (plan approved, a file's name, a task's id); Enter reads it, every field, and checks it: its content still gives its hash, it links to the entry before it, and the next entry links to it. Ctrl T shows only that entry's task; Ctrl S saves the whole chain to a file, in your home folder unless you give a path.

Contract and memory. /contract shows the boundary every task here works within: what it may change, what it never touches, how many files a task may change, the commands it may run and must pass, the reviews and approvals. Read the contract shows it as written; Redraft it from a description… has the model write one from your words, shown in full and saved only when you say so; each saved version can be read and restored; What Albert has learned here lists the notes in .albertcode/memory.md.

Requirements. /requirements lists what the app must do under Failed, Missing, Partial and Complete, with what proves each. Enter on one that is not complete puts the request to build it, prove it or fix it in the box, to read and send. Draft them from a specification… turns a brief into requirements, shown before they are kept; Add one… takes a title and, after a dash, a detail (Visitors can sign up — and confirm it by email); Ctrl D removes one.

Architecture. /architecture shows the parts of the repository, their technology and where they live, and how they connect, read from its own files. /architecture fresh reads them again.

Language checks. /checks lists each language and the checker that reads every edit Albert makes; Enter on one that can be installed installs it, after you say yes.

Tools and skills. /tools lists the tools and skills this repository can run with; Enter switches one on or off for it, saved at once and in force from the next task. One the contract bars says why, and Ctrl A offers to allow it in the contract, showing the exact line first. Save one of your commands as a tool… makes a tool of a command such as npm run lint; Ctrl D removes it.

Commands. /commands lists this repository's commands, yours and your plugins'. Enter puts one in the box to use; Make a command… asks its name, what it does, what it sends ($ARGUMENTS marks where the words after it go), when it is sent and where it is kept; Ctrl D deletes one.

Plugins. /plugins lists your plugins with what each brings. Enter switches one on or off, Ctrl U checks for an update and Ctrl D removes one. Install a plugin… takes a folder or an https Git address and shows everything it would add, its commands, agents and MCP servers, before anything is installed. Make a new plugin… starts one from this repository's commands and agents.

The app. /preview starts the app with its dev script (or /preview npm start with a command of yours) and says in a notice when it runs, and where; the box stays free meanwhile. Running, /preview offers Open it in your browser, Its output, Restart it and Stop the app, and, when it fails or answers with an error, Ask Albert to fix it, which puts what went wrong in the box. /preview stop stops it.

Browser tests. /test says the next step and takes it when you say yes: Albert writes the tests (as a task), the runner is installed, a browser is downloaded if there is none. Then Run the tests runs them in the background and a notice gives the result; /test lists them, failed first. Enter on a failed test offers Fix with Albert (a new session, given the error and how to run it), Run this file again and Read its error.

MCP prompts and resources. In /mcp, Use a prompt or resource… lists what your connected servers offer. A prompt asks for its answers, then fills the box to edit and send; a resource (one from a template, once its blank is filled) is read by the service and goes with your next message.

Keys in the terminal interface

/keys lists them in the terminal, with the answers at a gate.

The classic terminal

albertcode classic is AlbertCode's first terminal: one conversation at the AlbertCode SWE Agent> prompt, printed as it goes, with nothing drawn over your scrollback. It is what albertcode opens on a shared service or where the full-screen interface cannot run.

Slash commands in the classic terminal

Type /help for a list you can search by typing. Every command, by area:

Working

Models and providers

The repository

Evidence

Extending

The screen

Anything else starting with / is looked up as one of your custom commands, then as an MCP prompt; if neither exists, AlbertCode says Unknown command.

Lists and pickers

Model lists, /help, /tasks, /mcp and the other pickers work the same way: type to filter, use the arrow keys to move, Enter to choose and Esc to close.

Subcommands

Every step of a task is also a subcommand, so AlbertCode fits scripts and CI. Each prints JSON.

Sessions from a script

albertcode run "Why does the cart total round down?" --lane ask
albertcode run "Add a test for the 10% code" --approve plan,result     # both gates answered for you
albertcode run "Rename getUser to fetchUser" --lane direct_auto --json # every event as a JSON line
albertcode sessions --search discount
albertcode sessions show 3f9c2a71
albertcode sessions export 3f9c2a71 discount.json
albertcode sessions rename 3f9c2a71 "Discount codes"
albertcode models use openai:gpt-5
albertcode stats
albertcode docs browser tests
albertcode status

albertcode run works in a new session, prints what Albert says and does, and ends with the answer or the change. Without --approve, a governed change stops at its plan and the command exits with status 3: open the session (albertcode --session <id>, or in the browser) to read and answer it. --approve takes plan, result, writes or all, comma separated.

A task from a script

TASK=$(albertcode create "Add tests for the billing module" --workspace ./repo | jq -r .id)

albertcode show    "$TASK" | jq -r .state     # wait until it says plan_ready
albertcode approve "$TASK"                    # approval 1: the plan
albertcode show    "$TASK" | jq -r .state     # wait until it says completed
albertcode diff    "$TASK"                    # read the change
albertcode accept  "$TASK"                    # approval 2: apply it

A task moves through these states: received, planning_queued, analysing, plan_ready (waiting for approval 1), queued, implementing, verifying, reviewing, then completed (waiting for approval 2) or review_blocked, and finally accepted, rejected, failed, rolled_back or cancelled.

albertcode mcp

The same actions as /mcp, from a script:

albertcode mcp list
albertcode mcp add docs --command "npx -y @example/docs-mcp" --env DOCS_TOKEN=xyz
albertcode mcp add tracker --url https://mcp.example.com/mcp          # signs in with OAuth if it asks
albertcode mcp add search --url https://search.example.com/mcp --no-oauth --header "Authorization=Bearer xyz"
albertcode mcp auth tracker
albertcode mcp disable docs
albertcode mcp connectors
albertcode mcp install git repository=.
albertcode mcp remove docs

See MCP servers.

albertcode checks

albertcode checks                 # which languages are checked, and which can be installed
albertcode checks install python  # install Python's checker

Languages: python, typescript (TypeScript and JavaScript), go, rust, c (C and C++), php, shell and css (CSS, SCSS and Less). See Language checks.

albertcode compliance

albertcode compliance 3f2a91c0                       # readable summary
albertcode compliance 3f2a91c0 --format json > evidence.json

albertcode doctor

Shows the folders AlbertCode searches for tools, then each build tool it looks for (npm, npx, node, python3, pytest, git, go, cargo, dotnet), whether it found it, and where. Run it when tests don't run, or run with the wrong tool. If a tool works in your own terminal but doctor can't find it, your shell profile sets your PATH (a version manager does this): run albertcode stop, then start albertcode again from that terminal.

Profiles (the older way)

/connect and /model are the usual way to choose a model. Profiles are the older way, kept for scripts and shared services:

albertcode configure --name work --provider <provider> --api-key <key> --model <model>
albertcode configure --name local --provider local --base-url http://localhost:11434/v1 --model <model>
albertcode profiles                   # list them
albertcode --profile work             # use one
albertcode login --name team --url https://albertcode.example.com --api-key <key>   # a shared service
albertcode logout --name team

albertcode configure --help lists the provider names. --pace thorough|fast sets the pace of a profile.

Environment variables

Inside the browser's terminal, ALBERTCODE_TERMINAL=1 is set, so your shell scripts can tell they run there.