Skip to content
AlbertCode SWE
AlbertCodeFrom idea to working software

Software engineering, accelerated by AI.

Meet AlbertCode SWE Agent. A free-to-install AI coding agent, with open installers and documentation, built to help you go from ideas to working code.

Start Building Read the docs

macOS · Windows · Linux  /  no account  /  your model, or one running locally

The AlbertCode browser workspace at approval gate 2: the change is ready to accept, with its two changed files, the steps it took, and buttons to reject it, discard it, ask for changes, view the diff or accept it into your files.The AlbertCode browser workspace at approval gate 2: the change is ready to accept, with its two changed files, the steps it took, and buttons to reject it, discard it, ask for changes, view the diff or accept it into your files.
AlbertCode SWE Agent 1.54 in the browser, at the second approval gate. From the project's README, where the model's answers were scripted for the pictures.v1.54.1 — latest release on GitHub

What AlbertCode is

An agent that engineers the way you review.

AlbertCode takes a request in plain words and returns a change you can trust enough to accept: planned in the open, built away from your working tree, proven by your own tests, and applied only when you say so.

  1. It plans before it writes

    Every change starts as a plan you can read: the goal, the files it expects to touch, how it will test the change, and the risk.

  2. It proves the change

    The work happens in an isolated copy of your repository. Your own tests run there, and independent security and quality reviews read the result.

  3. You decide what lands

    Two human gates — the plan and the diff. Nothing reaches your working tree until you accept it, and Git stays your undo.

See it work

One request, from plan to proof.

Step through a governed change exactly as the agent shows it. Every screen is a capture of the product from its README — not a mock-up.

Gate 1 — approve the plan

You describe the change in plain words. AlbertCode reads the repository and proposes a plan: the files it will change, its steps, how it will be tested, a security note, how to undo it and its risk. Nothing has been written yet.

Approval gate 1: the proposed plan, with the files it will change, its steps, how it will be tested, its security note, how to undo it and its risk, and buttons to reject it, read the whole plan, ask for changes, or approve and build.Approval gate 1: the proposed plan, with the files it will change, its steps, how it will be tested, its security note, how to undo it and its risk, and buttons to reject it, read the whole plan, ask for changes, or approve and build.
Gate 1 — the plan: files, steps, tests, a security note, how to undo it, and the risk. Nothing is written yet.

Captures of the AlbertCode SWE Agent 1.54 interface from its README. The model's answers were scripted for the pictures.

The product

One agent, in your terminal, your browser and VS Code.

Every interface talks to the same engine — the planning, the isolated copy, the checks, the reviews and the two gates — so a task started in one can be followed in another.

v1.54.1 — latest release on GitHubalbertcode

AlbertCode SWE Agent

The coding agent that proves its work.

A coding agent that runs on your machine. It plans a change, builds it in an isolated copy of your repository, runs your own tests, reviews the result, and shows you the diff. Nothing reaches your files until you accept it.

  • Approval built in

    Two clear decision points — the plan and the diff — so nothing reaches your repository by surprise.

  • Proven, not just written

    Runs your own toolchain (pytest, npm scripts, go test, cargo, Maven, Gradle, dotnet) and shows what passed and what didn't.

  • Three interfaces

    Terminal, browser and VS Code, all driving the same local service and the same sessions.

  • Any model

    A hosted provider, OpenRouter, Hugging Face, any compatible API, or a model on your own machine.

Explore AlbertCode SWE Agent
The task board: seven tasks in five columns, Planned, Active, Blocked, Verifying and Completed, each card with its progress, what it waits for (a plan or a diff), its checks and files.The task board: seven tasks in five columns, Planned, Active, Blocked, Verifying and Completed, each card with its progress, what it waits for (a plan or a diff), its checks and files.
The task board: every task by where it stands, and what it waits for.

Also on the AlbertCode engine

mini-AlbertCode SWE Agent, a second agent with a full-screen terminal and a browser workspace, without the VS Code panel.

About mini-AlbertCode

How it works

Two gates. Nothing crosses them without you.

This is Governed mode, the default. Circles are work the agent does; diamonds are the two points where a person decides.

  1. 01

    Plan

    The goal, the files it expects to touch, the test plan and the risk. Nothing is written.

  2. 02You decide

    Approve

    You approve the plan, ask for changes, or reject it.

  3. 03

    Build

    The change is made in an isolated copy of your repository — never in your working tree.

  4. 04

    Verify

    Your project's own tests and checks run, and the change is reviewed for security and quality.

  5. 05You decide

    Accept

    You read the diff and the results, then apply it, ask for changes, or discard it.

Everything runs on your machine.

AlbertCode runs as a small service on your own computer, with the terminal, the browser workspace and the VS Code panel on top. A task started in one can be followed in another, and closing a window never stops the work.

  • Rejecting or discarding a change deletes its isolated copy: your working tree never saw it.
  • Saved keys stay in your system's keychain or keyring, and are never handed to the commands a task runs.
  • Accepted changes are ordinary edits in your working tree: review them with git diff, commit them, undo them with Git.
Your computer
TerminalFull-screen conversation, gates and lists
Browser workspacePlans, diffs, files and your running app
VS CodeThe same agent and gates, in your editor
Local service on 127.0.0.1Starts on first use and keeps running between windows. Answers only requests carrying this installation's access token.
Isolated copy of your repositoryWhere the change is built, your tests run and the reviews read it.
Your working treeChanges land only when you accept. Commit or undo them with Git.
The model you connectA hosted provider with your key, or a local model server — then nothing leaves your machine. No telemetry, no account.
Drawn from the agents' documentation (How it works, Security model). Both run only on your machine; neither is a hosted service.

Developer workflow

Built for the whole loop, not just the edit.

Each capability below is described in AlbertCode SWE Agent's own documentation.

  • Governed, Direct, Ask

    Choose the pace per request: two gates for changes you care about, direct edits you watch, or questions that change nothing.

  • Your toolchain, your tests

    pytest, npm scripts, go test, cargo, Maven, Gradle, dotnet — the project's own checks decide what passed.

  • Your app, beside the chat

    Run the project in a preview panel at desktop, tablet or phone width, with its errors surfaced and one click to ask for a fix.

  • MCP connectors

    Add MCP servers from a gallery of connectors, or your own by hand — local or remote, with sign-in.

  • Scripts and CI

    albertcode run sends one request without the interface and answers only the gates you name with --approve.

  • Any model, even local

    Hosted providers, OpenRouter, Hugging Face, any compatible API — or Ollama, LM Studio and friends, so nothing leaves your machine.

  • VS Code panel

    The same agent and gates inside your editor, from the .vsix extension attached to each release.

  • Contract and evidence ledger

    albertcode.contract.toml bounds what may change; every action lands in a hash-chained ledger you can export.

  • Requirements, architecture, browser tests

    A spec as a checklist backed by browser tests, what your app is made of read from its own files, and Playwright tests in your e2e/ folder.

Open by default

Open about everything — including what isn't open.

AlbertCode SWE Agent is a proprietary, free-to-install application. Everything you need to adopt, inspect and improve it lives in a public repository you can read, fork and contribute to.

Installers you can read

The one-line installers are plain shell and PowerShell, Apache-2.0, and verify each download's SHA-256 before running it.

Documentation under CC BY 4.0

Every guide, from installation to the contract format, is public and open to corrections.

Benchmarks with their evidence

A published methodology, per-task outcomes, and results labelled self-reported until someone independent checks them.

Private by design

No telemetry, no account. Your code goes only to the model you choose — or nowhere, with a local model.

What's open, and what isn't

Getting started

One command. Then describe the change.

The installer shows what it will do and asks before it changes anything. It installs for your user only — Python included — so there's no pip, virtual environment or PATH editing.

  1. 1

    Install

    Paste the command for your system and answer Y.

  2. 2

    Connect a model

    Paste an API key, or point it at a model on your machine.

  3. 3

    Ask for a change

    cd into a project, start the agent, and say what should change.

Full setup guideOpen the run planner

Install AlbertCode SWE Agent

for your user · asks before changing anything
Terminal
curl -fsSL https://raw.githubusercontent.com/huynvic/albertcode-swe-agent/main/installer/install.sh | sh
  • Open Terminal (⌘ Space, then type Terminal), paste the command, read the plan, then type Y.
  • Open a new Terminal window when it finishes, then run albertcode --version.

FAQ

Straight answers.

More in the documentation, and in each repository's own FAQ.

What is AlbertCode?
AlbertCode SWE Agent is an AI coding agent that runs on your machine. It plans a change, builds it in an isolated copy of your repository, runs your own tests, reviews the result, and waits for you to accept the diff before anything reaches your files.
Is it open source?
No — and we'd rather say so plainly. AlbertCode SWE Agent is a proprietary application. Its public GitHub repository holds the installers, the documentation, examples and the benchmark methodology, under Apache-2.0 (code) and CC BY 4.0 (docs), and welcome contributions. The engine's source isn't published. What's open, and what isn't.
Does it cost anything?
Installing is free and needs no account. AlbertCode doesn't charge for model usage: you use your own model provider's account, or a local model at no cost. The repository notes that terms for AlbertCode itself will be published with its first public release.
Does my code leave my machine?
Only to the model provider you connect (and to MCP servers you add), because the model has to read the code it works on. With a local model, nothing leaves your machine. There is no telemetry and no account. Saved keys are kept by your operating system's keychain or keyring.
Which models can I use?
Hosted providers with an API key, Kimi, Hugging Face, OpenRouter, any OpenAI-compatible service, or a model on your own machine through Ollama, LM Studio, vLLM or llama.cpp. The model must support tool calling; albertcode models test checks one.
Can it change my files without asking?
Not in Governed mode, the default: you approve the plan, then the diff. Direct mode works in your real files and asks before each write, unless you explicitly choose auto-approve. Direct needs Git, because Git is the undo.
Can I run it in the browser, here?
No. AlbertCode runs on your own computer; it isn't offered as a hosted service, and this website never runs code for you. Its own browser workspace opens on your computer with albertcode web. The run planner here prepares the exact commands for your system and reads the output you bring back — entirely in your browser.
What is mini-AlbertCode?
A second agent on the AlbertCode engine, with a full-screen terminal and a browser workspace. AlbertCode SWE Agent is the main one: it adds a VS Code panel and documents the repository contract, the evidence ledger, and the requirements, architecture and browser-test pages. If you use mini-AlbertCode, its page and full documentation are still here, and the two install side by side with nothing shared. Compare them.
Which systems are supported?
Windows 10 or 11 (x64, which also runs on ARM PCs), macOS on Apple silicon or Intel, and x86-64 Linux with glibc (Ubuntu 20.04+, Debian 10+, Fedora, RHEL 8+, openSUSE, Arch). Not Alpine or other musl systems, and not Linux on ARM. About 1 GB of disk.

Build faster. Ship smarter. Engineer with AI.

From idea to working software.

Install in a minute or two, connect the model you already use, and let the first change come back with its proof.

Start Building Read the docs