Silver conducts better than any metal.
A conductor also turns a room full of players into one piece of music. Argent does both for your coding agents: every task flows through one place, each agent plays its part in its own branch, and you hold the baton when it’s time to merge.
Without a conductor, agents are just noise:
“Done” is only a claim
“All tests pass, ready to merge” is a sentence the agent wrote. Nothing attached to it shows which commit was tested, or whether anything was.
A terminal per task
Each agent wants its own window, its own branch and your attention. Run three and you spend the afternoon switching tabs.
Your laptop is the leash
Close the lid and the work stops. Step away from your desk and you lose sight of what your agents are doing.
An agent’s word is not proof.
Silversmiths have stamped hallmarks on their work for centuries, so anyone can check a piece without taking the maker’s word for it. Argent brings that idea to code: the record of a run is collected by Argent itself, tied to the exact commit and kept apart from what the agent says.
What the agent says
Self-reported. No commit, no check results, no review attached.
What Argent records
- Status
- Verified
- Commit
- 9b1e07d
- Checks
- 39 of 39, from the project’s policy
- Review
- 1 finding, repaired once
- Verified by
- Argent’s verifier, not the agent
- Merge
- Waiting for you
Illustrative example · drag the divider or use the arrow keys.
Today, a Claude Code run completes only after Argent records the branch, the commit, the changed files and a checksum of the diff itself. That is a record of what changed, not a test result.
Checks that Argent runs itself against that exact commit, and a draft pull request that carries the result, arrive with the local MVP.
The four marks of a complete record. The app strikes two of them today:
Who did the work
The maker’s mark: which agent ran, and the limits it ran under.
Struck:Works todayWhat it had to pass
The standard mark: checks from your project’s policy, which the agent can’t change.
Not struck:PlannedWho checked it
The assay mark: an independent verifier, never the agent that produced the work.
Not struck:PlannedWhich commit
The date letter: the exact commit the record is tied to.
Struck:Works today
Three steps.
You hold the baton.
This is the workflow of the local MVP, the first release. Real agents run on your own computer, through their official command-line tools and your own sign-in: Claude Code first, then Codex in the first update. The first two steps work today; the third is being built.
task.md
Rate-limit the login endpoint.
- Five failed logins lock the account for 15 minutes
- A successful login resets the counter
- Locked responses return 429 with Retry-After
01Describe the work.
Choose a repository and write the outcome you want. Plain language is enough.
Works today- argent/rate-limit-login
- argent/flaky-upload-test
- argent/docs-typos
02Agents run side by side.
Each task gets its own branch and Git worktree of your repository, so parallel agents never overwrite each other. Follow every session live, send follow-ups, or stop it.
Works today- return login(user, password)
+ if (await locked(user)) return tooMany()
+ return login(user, password)
Tests passed on 9b1e07d
Merge is yours03Review the evidence. Then merge.
See the real diff and the test results recorded for the exact commit, separate from what the agent says. Argent opens a draft pull request; merging is always your call.
In development
Illustrative example. Local mode is not a sandbox: an agent has the same access as running it in your terminal, and a worktree separates changes, not privileges. Read the local MVP spec.
Your agents.
Your models.
Claude Code runs in the desktop app today. Codex joins it in the first update after release, so Claude models and GPT models can work side by side, each in its own workspace, on the subscriptions you already have. You pick the agent for each workspace and the model for each task, or keep the agent’s default.
Later
- Cursor
- OpenCode
An illustration of the planned picker. Each agent runs through its official command-line tool under your own sign-in; which models you can choose depends on your plan, and Argent never routes models or switches to paid API usage. Claude and Claude Code are trademarks of Anthropic; OpenAI, Codex and GPT are trademarks of OpenAI. Their logos appear only to identify the agents Argent works with; Argent is not affiliated with either company.
Open source
Yours to run.
Yours to keep.
Your code, your agents and your history should not depend on one company staying kind, including ours. So Argent is open source by design, not by marketing: these are the promises it is built around.
MIT, all of it.
The core is MIT licensed. Read it, fork it, change it and run it wherever you like.
MIT core:Works todaySelf-hosting is not plan B.
Argent runs without our servers. A managed cloud, if we offer one, would run the same core, so self-hosting is never the lesser option.
Same core:Project ruleYour agents, your sign-in.
Agents run through their official tools under your own account. Argent never reads or copies that sign-in, and keeps API keys away from agents so you are never silently billed.
Claude Code:Works todayYour history leaves with you.
Export your Argent history and restore it on another machine. No lock-in to us, to one model or to one vendor.
Export and restore:Works todayStops when it isn’t sure.
If a run’s outcome is unknown, Argent marks it for a person to inspect. It never repeats something that may already have happened.
Lost-worker handling:Works todayNothing advertised before it works.
Every claim on this page is labelled works today, in development or planned, and matches the code on GitHub.
Honest labels:Project rule
Free, for anyone who runs it.
The desktop app and the engine are free and MIT licensed, and you use the agent subscriptions you already have.
A managed cloud, later.
For people who would rather not run servers, we may offer hosted workspaces as a paid service. It would run the exact same core, and your history would stay exportable. Nothing is for sale today.
Where Argent is going
Start at your desk.
Finish from anywhere.
One task, three places, one record. The desktop app is where work begins, a machine that stays on is where it keeps going, and your phone is where you hear it is done.
- 01
Hand it off at your desk.
Choose a repository and describe the task. Your agent starts in its own branch and worktree, so several tasks run side by side without overwriting each other.
Local MVP:In development - 02
Close the lid. It keeps going.
A remote workspace keeps the repository, dependencies and history alive while you are away, on the same open-source engine: first on a machine you own that stays on, later in an optional managed cloud.
Remote workspaces:Planned - 03
Check in from your phone.
A native iPhone companion shows progress, the diff and the evidence, and lets you steer or stop the agent. Merging stays yours.
iPhone companion:Planned
An illustration of the planned experience, not a live system. Today, the desktop app runs Claude Code in local worktrees (early, and not a sandbox); Codex, remote workspaces and the iPhone companion are still ahead.
Early, and honest
about it.
Each step ends with working evidence, not a date. After these come team handoff and dependent tasks. Read the full roadmap.
Works today
Engine and desktop prototype
Durable runs, crash recovery, reconnect and independent records of what changed, in a local macOS app you build from source.
In development · Claude Code runs today
Local MVP
Claude Code already runs in the app, each task in its own branch and worktree with a live session. Still to come: the diff, checks Argent runs itself against the exact commit, and a draft pull request that carries the proof.
Planned
Public downloads
The first release: a signed build for Macs with Apple silicon, with Claude Code and a checksum, downloadable from this site.
Planned
More agents
Codex and a model picker as the first update, then Cursor and OpenCode, each through its official tool.
Planned
Remote workspaces
Hand off a task, close your laptop, and come back to a tested draft pull request. First on a machine you own that stays on, later in an optional managed cloud.
Planned
iPhone companion
Check progress, review the evidence and steer your agents from your phone.
Works today
- A durable engine that survives crashes and never repeats an uncertain step
- Claude Code in the desktop app, one branch and worktree per task (early, not a sandbox)
- A local macOS desktop app, built from source
- Argent’s own record of what each run changed
- History export and restore, from the command line
Not yet
- Diff review, tests and pull requests in the app (in development)
- Codex and the model picker (the first update after release)
- Work that continues with your laptop closed, and the iPhone companion
- Signed downloads: today you build from source
Fair
questions.
What works today, what it will cost, and where you stay in control.
Can I use Argent today?
Yes, if you build the desktop app from source. It runs Claude Code on your local repositories, each task in its own branch and Git worktree, with your own sign-in. It is early and not a sandbox, and diff review, tests and pull requests are still in development. Today it runs on Macs with Apple silicon; Windows, Linux and Intel Mac builds have not been made or tested. Star and watch the repository to hear when signed downloads land.
Which agents and models will it support?
Claude Code works in the desktop app today, and the first release ships with it. Codex is the first update after that, together with a model picker, so you can use Claude models and GPT models and choose the agent for each workspace and the model for each task. Cursor and OpenCode follow. Each agent runs with its own official sign-in, so you use the subscription you already have. Argent never reads or copies that sign-in, and it keeps provider API keys away from agents, so a missing sign-in fails visibly instead of quietly billing your API account.
Is it safe to let agents run on my computer?
Local mode is not a sandbox, and Argent says so. The agent runs as you, with the same access as running it in your terminal; a worktree separates changes, not privileges. What Argent adds is discipline: no shell strings, validated paths, Git commands that never run repository hooks, a minimal environment for the agent, and a person in charge of every merge. Read the security model.
Does work keep running when I close my laptop?
Not yet. Today the local service survives quitting the app, but your computer has to stay awake. Work that keeps running while you are away comes after the first release: first on a machine you own that stays on, running the same engine, then in an optional managed cloud, followed by the iPhone companion.
What happens to my work if Argent goes away?
It stays where it already is: on your computer. Every workspace is an ordinary Git branch and worktree of your own repository, so your code never lives inside Argent. The app and engine are MIT licensed and run without our servers, your agents keep their own sign-in, and your Argent history can be exported and restored on another machine (from the command line today). No hosted service of ours sits between you and your work.
Will it cost anything?
The desktop app and engine are free and MIT licensed, and stay that way. We may later offer a paid managed cloud for people who would rather not run servers. It would run the same core, and self-hosting would remain a first-class option.
How is it different from running agents in a terminal?
Argent doesn’t replace your agent; it conducts it. Today it gives every task its own branch and worktree, keeps a durable record of every run and records what changed itself instead of trusting the agent. The rest of the local MVP adds diff review, tests for the exact commit and a draft pull request you merge yourself. It is open source, built for more than one agent, and designed to continue on a machine that stays on and on your phone.
Who decides what gets merged?
You do, always. In the local MVP, Argent’s work ends at a draft pull request with its evidence; merging is a separate human action. Read the architecture for the execution and approval boundaries.
Run it on
your Mac today.
There is no download yet, so today you build Argent from source. It takes three commands.
The real thing, early. Choose a repository and hand Claude Code a task in its own branch and worktree, signed in as you.
You need
- A Mac with Apple silicon
- Git and Node 22.19 or a later Node 22
- The Claude Code command-line tool, up to date and signed in
Local mode is not a sandbox: the agent runs as you. Read the security model before pointing it at a repository you care about.
$ git clone https://github.com/GregPat22/argent $ cd argent && npm ci $ npm run desktop # what happens next, in the app 1 Choose a local repository. 2 Argent creates branch argent/<id> in a private worktree. 3 Describe a task. Claude Code runs there, signed in as you. 4 Follow the session live, send follow-ups or stop it. 5 Argent records the commit and what changed. recorded, not tested limitations Not a sandbox. No diff view, tests or pull requests yet.
Join the build.
Argent is built in the open, one verified step at a time. Star and watch the repository to hear when signed downloads land, and follow the build on X.
On GitHub, choose Watch, then Custom, then Releases. Want to help build it? Read the contributing guide.