Orca vs T3 Code: how I stopped babysitting my agents

My editor history reads a lot like my school history: I kept moving. VS Code, then VS Code with Codex bolted on, then Cursor, then Orca, and now T3 Code. Seven schools before tenth grade taught me that the new place is never the problem. Until it is.

This is the story of the latest two moves, and of why the tool that gave me the most control lost to the one that mostly leaves me alone.

VS Code, then VS Code with a sidekick, then Cursor

VS Code was home. I typed every line myself, which felt honest and was mostly slow. Then I put Codex in a side panel, and pretty soon the side panel was writing more code than I was. Cursor was the obvious next step: same muscle memory, AI baked into everything.

All three had the same shape, though. One editor, one project, one conversation, and me in the middle approving diffs like a very tired customs officer. The AI wasn't the bottleneck. I was, and every tool was built around me being the bottleneck.

Enter Siam

Then my buddy Siam did what good friends do: dropped a link in the chat and said "just try it". First it was Orca. A while later, T3 Code. Bro, he was right both times. I've stopped arguing with his links.

Orca: built for the one-project control freak

Orca calls itself an agent development environment. Every task gets its own git worktree, and Claude Code, Codex, OpenCode and friends run side by side in one window. When I worked on one project at a time, it was exactly what I wanted: everything in view, everything under my thumb.

What it does really well:

• Orchestration. Type /orchestration and the session becomes a coordinator: it splits the work, dispatches tasks to worker agents, waits on them and gates the decisions. You opt in, so you always know when it's happening.
• Computer use. The best I've used. Agents drive real desktop apps through the accessibility tree: click, type, read dialogs, take screenshots. When there's no CLI or API for something, this is the escape hatch.
• Account switching. Effortless. A built-in switcher shows your Claude and Codex usage and when the rate limits reset, and swaps accounts without logging in again. Very useful when your weekly limit runs out on a Tuesday. Not that I'd know.
• A layout you already know. Worktrees in the sidebar, terminal splits, file tree, source control. If you've used VS Code you're productive in ten minutes.

What wore me down:

• It hogs your attention. Every agent finishing, every unread thread, every status change wants a look. With one project that's fine. It's your project, you want to look.
• Remote development. SSH worktrees on a beefy remote box, with auto-reconnect and port forwarding, are genuinely cool. Day to day, I still wouldn't build my setup around them.

Then I had five projects

The day job, the research lab, this site, and a side project or two. With 3 to 5 projects running at once, Orca's "everything in view" turned into "everything shouting". Every badge was a tap on the shoulder. Being in control of five things at once just means being interrupted five times as often.

I didn't need more control. I needed a tool that only got my attention when there was something worth looking at.

T3 Code: where I am now

T3 Code is the open-source app from Theo's team for running coding agents: Claude Code, Codex, Cursor, OpenCode, Grok and Antigravity, on the subscriptions you already pay for. It's free, MIT-licensed, and runs on desktop, web, iOS and Android.

• It only asks for attention when it needs you. Threads finish quietly. The ones waiting on a decision, a review or a failed check come back to your inbox. This is the best version of this idea I've used, and it's the reason I switched.
• Orchestration is best in class, and you don't have to call it. Ask for parallel work in plain words and the coordinator delegates to other models, each in its own worktree, across providers. An Opus coordinator handing work to Codex and Sonnet is a normal Tuesday. It can watch a PR and wake up when the checks finish, and recurring jobs go on a schedule instead of a cron job you forget about.
• A built-in browser and real emulators. My favourite part. The agent opens the page it just changed, clicks through it, shrinks it to phone width, or boots an iOS or Android emulator and takes screenshots. Testing and debugging stop being a context switch.
• Remote development is the best I've used. Run the server on one machine and connect from anywhere: T3 Connect, LAN pairing, Tailscale or SSH.
• A clean layout. There are a lot of settings. You set them once and then forget they exist.
• The rough edge: account switching. Multiple Claude or Codex accounts work, but setting it up takes some fiddling. Orca wins this one easily.

Orchestration, side by side

Here's the same prompt in both apps. In Orca, /orchestration switches the session into coordinator mode. In T3 Code there's no command: the coordinator picks the intent up from the wording. Everything after that looks the same: workers in their own worktrees, a verifier spawned under each one, a fixer at the end, and one ping for you.

Both live on your phone

Both apps have a phone companion. Orca's lets you monitor and steer your agents and send follow-ups from anywhere. T3 Code's is the one that stays on my home screen: threads, diffs, PRs and follow-ups, all from the phone, and it's fast. It feels like the GitHub app GitHub never managed to become.

The setup I'd actually recommend

The best way to code right now is to prompt from whatever you're carrying (phone, tablet, laptop) while all the development runs on a machine that stays at home: a Mac mini, a VPS or an old PC. A Mac mini is my pick, because it sips power and still builds fast. Then go on with your life, and only talk to the agents when they ask for you.

flowchart LR
  you["phone, tablet or laptop"] -->|prompt| box["mac mini at home"]
  box --> w1["agent in worktree 1"]
  box --> w2["agent in worktree 2"]
  box --> w3["agent in worktree 3"]
  w1 -->|only when it needs you| you
  w2 -->|only when it needs you| you
  w3 -->|only when it needs you| you

This changes what the job is. When agents write most of the code, the valuable work moves up a level. You decide what gets built and how the pieces fit together. You set up the infrastructure the agents run on: worktrees, environments, CI, previews, the machine at home. And you write the checks that decide when something is actually done. Your leverage isn't how fast you write a function any more. It's how well you design the system, brief the agents and review what comes back.

Always on the lookout

If all this moving taught me anything, it's to keep an eye out for what's next. Mostly it taught me to be active on X, which is where every one of these tools showed up first.

There are others I haven't tried yet, like Capy, a browser IDE where a planning agent hands tasks to build agents, each in its own VM. I might give them a go later. For now, T3 Code is working well for me. If something better comes along, I'll move. I always do.

Where to start

Start with Orca. It shows you everything, which is exactly what you want while you're learning how agentic coding flows: worktrees, parallel agents, handoffs. Once that feels natural and you're running more than one project, move to T3 Code and let it go quiet.

One last thing: if you prompt all day, typing speed matters again. I wrote about how I got faster at typing.

Five editors later, I'm still moving. The difference is that the agents do the work now, and they only call when they need me. Character building, allegedly.