One conversation
runs the whole job.

Tell Blocks what you want. Its orchestrator plans the work, hands it to coding agents running side by side, each on its own git branch, reviews what they did, merges it and runs the checks. You stay in one chat, and it asks only when something truly needs you.

For Linux, macOS and Windows. With a companion iPhone app.

atlas atlas-ios notes 2 running
Add passkey sign-in to the web app, and let the iPhone app use it too.

Three parts that don't share files: the server's WebAuthn routes, the web sign-in page and the iPhone flow. I've landed the shared types first, so all three start together.

AdaServer routestask/server-routes
IrisWeb sign-in pagetask/web-sign-in
NooriPhone flowtask/ios-passkeys
Ada finished

Reviewed and merged Ada's server routes. The checks pass on the merged result. Iris and Noor are rebasing on it.

1Ship it behind a flag first?
Enter for Yes, behind a flag, or type another

Four steps, one place to watch them.

Every request goes the same way. You see the decisions and the outcomes, not a scrolling log.

  1. Plan

    The orchestrator reads enough of your code to split the request into tasks that don't share files, and lands any shared contract first.

  2. Hand out

    Each task goes to a worker agent with a short name, its own branch and its own worktree. They run in parallel and never step on each other.

  3. Review

    When a worker finishes its turn, the orchestrator reads the diff and sends it back with notes until it's right.

  4. Merge and check

    Approved work is merged into the session's integration branch, the checks run on the combined result, and you get the outcome in a few lines.

Ada server routes Noor iPhone flow integration merged merged, checks pass

It asks only when it truly needs you.

You're never the bottleneck. A question that's yours but not urgent arrives with a sensible default, and the work goes on; if you haven't answered by the time it matters, the default stands.

Anything that leaves your machine or can't be undone waits for your yes: pushing, opening a pull request, publishing. Everything else keeps moving.

There are no buttons to hunt for. You answer in the message box: Enter takes the default, typing gives another answer, Esc declines.

The agents you already use, on your own accounts.

Blocks runs the coding CLIs you have: Claude Code, Codex, OpenCode, Grok and Kimi, each signed in to your own plan. Add a work account beside a personal one, pick which one the orchestrator and the workers use, and change it mid-session by asking.

It watches every usage window your plans report and tells the orchestrator when one is nearly spent, so the work can move before it stops.

Experts who remember their part of the code.

An expert is a persistent agent that owns an area of your codebase and keeps notes on it across tasks and sessions. Work in its area goes to it, and it can watch paths: when a change lands there, it reviews it on its own.

@iosios/**

Owns the iPhone app. Knows the design tokens, the simulators it builds on and why the sign-in sheet works the way it does.

@backendserver/**

Owns the API and its migrations. Keeps the contract with the apps in its notes, so the next task starts from it.

@securitywatches **/auth/**

Owns nothing, watches the sign-in code. Every worker turn that changes it gets a review, and the findings go straight to that worker.

Everything the window does, you can ask for.

Settings, schedules, connectors, accounts, new projects: the orchestrator does them with its own tools while you keep talking. The window is there to look at, not to operate.

  • Pair my phone.
  • Every Friday at five, check the backups.
  • Use Codex for the workers on this one.
  • Add our Linear MCP server here.
  • Open a pull request once the checks pass.
  • Start a separate project for the CLI.

Your sessions, in your pocket.

The companion iPhone app pairs with Blocks on your computer. Follow every project, answer what's waiting, send the next message, or call Blocks and talk it through. The work stays on your computer; the phone is a window onto it.

To pair, ask in chat: “Pair my phone.”

Get Blocks.

Bring the agent CLIs you already use. Blocks finds them and runs them on your accounts.

On iPhone: the companion app pairs with Blocks on your computer.