Superhuman for software development
Lattis is a desktop workspace for running many coding agents at once — each on its own branch, each with a stoplight that tells you who's working, who's stuck, and who's waiting on you. Open pull requests, review the ones your team sends back, and merge without leaving the app. And because every token flows through one endpoint, you see exactly what each agent costs.
macOS · Linux · Windows
Why Lattis
Lattis is built to keep many agents moving while keeping you out of the weeds — and to clear the queue they create downstream, where your team is waiting on a review. The bottleneck stops being you, and the bill never surprises you.
Run Sawyer — Lattis's built-in agent, with nothing to install — alongside Claude, Codex, Pi, and OpenCode, each on its own branch and worktree. Tile them like i3: split panes, drag tabs between them, maximize what matters — and every branch remembers its layout.
Every agent gets a stoplight: green is working, amber is waiting on you, red hit an error. Scan a dozen branches in a second and spend your attention only where it moves the work forward.
Each branch shows its live PR state and CI checks — ready, awaiting review, blocked — with a color you can read across the room. Open, mark ready, merge, push, and pull without opening a browser tab.
The Review layout reads the branch as one diff against its merge base, in a guided order — code first, lockfiles last. Mark files viewed, comment on the lines that need it, and come back to only what changed since your last pass.
Assist runs a read-only agent pass over the branch and returns a triage queue: correctness, design, compatibility, CI, tests and docs, each finding graded and anchored to a real line. Accept one and it becomes your draft comment. Nothing reaches the PR until you say so.
Every pull request GitHub asked you to review lands in the sidebar, oldest first. One click checks the branch out and opens it for reading — and the checkout cleans itself up when you post the verdict.
Token tools, at best, show tokens. Lattis shows dollars — per project, per model, per conversation — across cloud and local models alike. Know what each agent costs while it's still running.
Connect Anthropic, OpenAI, OpenRouter, and Bedrock, or run models on your own hardware — then point every agent at one endpoint and route each task to whatever's cheaper or faster. Lattis fails over across your accounts and providers when one errors. Your keys, your models, no token markup.
Agents read freely, but anything that changes your repo or machine stops for a one-click approval. Grants last the session, so you confirm once and keep moving.
Status you can read across the room
The hard part of running many agents isn't starting them — it's knowing which one needs you next. Lattis gives every agent and every branch a color. Glance at the sidebar and you know what's running, what's blocked on CI, what's ready to merge, and what's parked waiting for your answer.
How the lights work →Agent status
Pull request & CI
Close the loop in one place
An agent finishes, opens a PR, and pushes. You see the checks go green and merge — without alt-tabbing to a browser, a terminal, and back. The diff opens in the editor, and the PR state and spend sit next to the agent that produced them. Lattis then offers to ask for a review, and ranks the people who wrote the code you changed.
› Split the tender logic into its own module and add tests.
⏺ Read src/checkout/tender.rs
⏺ Edit src/checkout/tender.rs +84 −12
⏺ git git.status
cargo test — 24 passed, 0 failed
✓ Done. Opened PR #214 and pushed.
▍
All checks passed · 1 review required
Uncommitted (2) +18 −2
M tender.rs src/checkout +14 −2
A tender_test.rs src/checkout +4 −0
Committed (5) +402 −34
Team productivity
So Lattis takes on the other half of shipping. Every review your team asks of you lands in the sidebar. One click checks the branch out and opens it as a single guided diff — comment on the lines that need it, put an agent on a first pass, and post a verdict that arrives on GitHub as real line comments, not a wall of text.
Core changes
✓ tender.rs +184 −22
gateway.rs +96 −4
! mod.rs +12 −0
Tests
tender_test.rs +108 −0
141 let total = items.iter().map(|i| i.cents).sum();
142 let split = total / parties;
142 let split = total.checked_div(parties)
143 .ok_or(TenderError::NoParties)?;
144 Ok(Split { split, remainder })
issue you
`checked_div` returns `None` on zero, but the remainder is still computed from the old total. Carry it through.
One diff against the merge base, in a guided order: code by churn first, lockfiles last. Files you've read stay marked — and a mark goes stale the moment that file changes. Come back later and read only what landed since your last pass.
Click any line to leave an issue, a question, a nit, or some praise. Threads stay local until you finish — then approve, request changes, or just post comments, and each thread lands on the line it describes, pinned to the revision you actually read.
Assist reads the branch — read-only, no shell — and files findings against five lenses, graded critical to nit and anchored to real lines. You triage: accept one and it becomes your draft comment, dismiss the rest. Unvetted output never reaches the author.
Auto Fix compiles your open threads into one numbered task and hands it to an agent on that worktree, in the background. The review you just wrote becomes the next branch's to-do list.
The bill, per agent
Most agent tools hide spend behind credits, or ignore it entirely. Lattis attributes every request and shows the dollar cost — by project, by model, by conversation — for cloud models, while local models stay free. Decide what belongs on a frontier model and what a local one can handle.
Want the same numbers for your whole team? The Lattis web app at app.getlattis.ai rolls spend and activity up across everyone's machines — traces, sessions, cache savings, and org-wide reporting. Sign in with GitHub, Google, or a magic link, then connect your desktop app in one click.
Cloud and local, side by side
Point every agent at a single endpoint and let Lattis route each request — to a frontier model in the cloud or a model on your own hardware. Mix vendors freely — Anthropic, OpenAI, OpenRouter, Bedrock — in a priority order you set, and Lattis fails over to the next account or provider when one errors, with no per-tool setup.
Connect a provider →Get going
Download the desktop app and open it — local inference is built in, nothing to compile.
Point Lattis at a git repo and connect the models your agents will use.
An agent spins up in a fresh worktree. Open as many as you like — they never step on each other.
Answer the amber ones, review the branch, request a review, and merge — all without leaving the app.
