Omniscio

OmniscioCompareT3 Code vs Herdr

T3 Code vs Herdr: which one should you run your agents in?

Pick T3 Code if the work should end in a reviewed pull request: a client you open on desktop, browser or phone, driving the agent CLIs you already pay for. Pick Herdr if the agents should outlive the window: a runtime that holds their terminals.

T3 Code can give a thread its own worktree, a separate copy of the repository on its own branch, and a diff, before walking you through review, merge and the checks in between.

For Herdr, closing the app, updating it or dropping the network leaves every agent working, and any machine you reach over SSH joins the same list.

T3 Code says plainly that it is not a harness: it drives the agent CLIs you install rather than running the model itself. Herdr says plainly that it does not wrap the agents, it just owns their terminals.

As of November 2026 both are free and open source (T3 Code under MIT, Herdr under Apache 2.0), and neither sells you model access.

Where each question is answered.
You wantRead this
The two side by sideAt a glance
What T3 Code does wellT3 Code
What Herdr does wellHerdr
Close the app, reboot, several machinesThe differences
A straight answer for your caseWhich to use
How this page was checkedHow we tested
Every source, with its dateSources

Every fact about both tools was read from the vendor's own pages and documentation on November 8, 2026. By the Omniscio team. Updated .

How do T3 Code and Herdr compare?

T3 CodeHerdr
What it isA desktop, web and phone client for the agent CLIs you already run, published by the pingdotgg organisation.A runtime that owns the agents' terminals, with a native app on top of it and a terminal app beside it.
PlatformsWindows, macOS and Linux on the desktop, in a browser, and on iOS and Android.macOS on Apple silicon, Linux on x86_64 and arm64, and Windows x86_64, with more machines over SSH.
Price and licenceFree and open source under MIT. Its connect service is free for three machines, with more behind a paid T3 Chat plan.Free and open source under Apache 2.0, across the app, the runtime and the terminal app.
AgentsWhatever CLI you install and sign in: Claude Code, Codex, Cursor, Grok Build, OpenCode, Antigravity, Kiro, Pi, Muse Code and more.Anything that runs in a terminal. The app shows state only for agents that report it themselves; the terminal app reads 22 out of the box.
A task's own copyOptional: a new thread can start in a new git worktree with its own branch, or in the project folder.Both of its products can make a Git worktree checkout and open it as a space nested under its repo, the app from a prompt like "open a worktree for issue 42", the terminal app from a Git workspace row.
Review and mergeA diff pane, pull-request review with comments, merge and auto-merge, and a beta guide that tours a change.Outside the product. Its documentation describes terminals and worktrees, not diffs.
When you close the appThe desktop app's local server stops with its last window; the host machine has to stay up for a phone or browser to reach it.Every agent keeps running in the runtime, on this machine and on any SSH host you added.
Where it livesIts own window, a browser tab, or a phone.A native window, or a terminal, on top of the same runtime.

Neither tool ships the model. T3 Code drives CLIs it expects you to install and sign in yourself, and Herdr holds terminals until something is running in them.

Whatever account is behind that CLI is the one that gets the bill.

What does T3 Code do well?

A client, and clear about what it is

T3 Code is a client, and it is unusually clear about that. It calls itself the open-source control plane for coding agents and says it is not a harness. It uses the harnesses you already have, and it will not start a thread without one.

Install and sign in to a provider CLI on the machine that runs the server, enable it in settings, and the same window drives Codex, Claude Code, Cursor, Grok Build, OpenCode, Antigravity, Kiro, Pi and Muse Code.

Each provider is a card you can point at a binary path, update, or duplicate for a second account with its own environment variables.

A thread, and its own copy of the repository

T3 Code's unit of work is a thread, and a thread can have its own copy of the repository.

Choose a new worktree when a task needs a separate branch and working directory, and it is made for you; leave the setting alone and the thread runs in the project folder. Worktrees land in a folder you choose.

Turn on cleanup and T3 Code removes them after idle days, once a thread settles, after a merge, or when they carry no commits beyond the default branch.

The diff pane keeps a turn's view to that turn's own work so a merge or a rebase elsewhere does not bury it. A branch comparison shows everything against the base, and a commit view walks the newest hundred one at a time.

From a finished turn to merged code

The path from a finished turn to merged code is the part T3 Code spends most of its effort on.

It talks to GitHub, GitLab, Forgejo, Gitea, Bitbucket, Azure DevOps and GitCafe directly, so a thread can clone a repository, publish one, open a pull request and review it without a browser.

Comments, reviewers, checkout and merge all live in the app, auto-merge is there for GitHub, GitLab and Azure DevOps while checks are still running, and a beta guide tours a pull request in reading order for the ones nobody wants to read line by line.

An agent can also watch a pull request: the server checks it every two minutes and wakes the agent when a check fails, the required checks pass, someone comments, or the branch starts to conflict.

Reach across devices

Reach is the other thing it does well. The same threads are in the desktop app, in a browser, and in the iOS and Android apps, with T3 Connect, LAN pairing or Tailscale carrying the connection and no OAuth callback port to forward.

An MCP server lets agents T3 Code did not start, such as Claude Code or Codex in your own terminal, ChatGPT or a bot, read projects and threads and start or message threads at an access level you choose, from read-only up.

A Usage view merges the histories of every provider it drives and shows token use, cache savings and an estimated API-equivalent cost that it is careful to call an estimate rather than your bill.

The project moves fast: 0.1.7 was the newest stable release on 4 November 2026.

What does Herdr do well?

One thing to know first: Herdr is three programs sharing a name, so this page says which it means each time.

  • herdr-core is the runtime that holds the terminals.
  • The Herdr app is the newer desktop client built on it.
  • Herdr TUI is the original terminal app, which keeps its own server and does not share agents with the app.

The programs live in a server

Herdr starts from the opposite end. The programs you run are not inside a window; they are inside herdr-core, a small server on your machine, and a window is one way to look at it.

Run something with hc run and it waits like a shell; run it with hc run --bg and it returns while the program keeps going; hc ls lists what is alive and hc attach takes one over.

Quit the app, update it, or let it crash, and every terminal is still where you left it. That is the whole pitch, and it is a real difference in kind rather than a feature on a list.

Status that the agent reports

The state of each agent is the other half. herdr-core draws nothing and guesses nothing: a terminal's working, done or needs-you state is what the program inside it reports through OSC 7501, an open status protocol, so there is no screen scraping and no list of known agents that has to be taught a new tool.

Your own script can report it in one line. The trade is honest: an agent that does not speak the protocol still runs, it just runs without a status.

The Herdr TUI, the older terminal app, takes the other road: it reads each pane and detects 22 agent CLIs out of the box.

Agents that drive other agents

Herdr treats agents as things that can drive other agents. One agent starts a helper with hc run --bg, tells it where to report, waits on it with hc wait, reads what came back and steers it with hc send, and helpers live under the agent that started them and stop when it stops.

The runtime's API is open to clients other than the app: a phone app, an editor panel, a Stream Deck, with hc schema printing it as OpenRPC.

Two smaller things

Every machine you can reach over SSH joins the same list, and its agents keep running there while your laptop sleeps.

The app is meant to be changed: its layout, sidebar, tabs, keys and themes are plain files in ~/.config/herdr-app, with an AGENTS.md in that folder explaining to your agent what it may rewrite, which is why the gallery can list 215 layouts and 435 mods made by other people.

The app, the runtime and the terminal app are all Apache 2.0.

Where do they differ most?

A client you open, or a runtime underneath

This is the difference the rest of the page comes out of. T3 Code is the place the work happens: threads, worktrees, diffs, pull requests, a browser, a phone.

Herdr is the layer the work sits on, and its app is one client of it beside the terminal app and anything you build on the API. Close T3 Code's last window and its local server stops. Close Herdr's app and nothing stops.

What your agent actually is

T3 Code knows what is running in a thread, because it starts the provider itself and speaks to it: it can show usage across the providers it drives, and it offers four permission modes.

Herdr knows only what the terminal reports, which makes it indifferent to which agent is on the other end, and equally unable to tell you anything an agent does not volunteer.

If you switch agents often, that indifference is a feature. If you want the app to total up what your Codex runs have cost, it is a gap.

The work that happens after the agent stops

T3 Code carries a change from a diff to a merged pull request inside one window, with comments, reviewers and auto-merge, and it can have an agent watch a pull request and wake when a check fails.

Herdr's own documentation covers terminals, panes, agents, sessions, machines and Git worktree checkouts, and describes no diff review or pull-request flow of its own.

If review is where your work goes next, T3 Code already lives there and Herdr expects you to bring something else.

What survives when you close the window

For Herdr, everything: the processes are in the runtime, and quitting or updating the app changes nothing.

For T3 Code, nothing keeps running, unless you install the background service on Linux or macOS, and a Windows host keeps t3 serve running in a terminal instead.

Its phone and browser clients are exactly that, clients, so the machine doing the work has to stay awake, and its connect service is free for three of them.

What happens after a reboot

Each of the three handles a reboot differently. Herdr's app is blunt: the programs stop, the panes come back with a shell in the same folder, and it does not restart an agent or resume its work.

The older Herdr TUI goes further, restoring the layout and resuming an agent's own conversation by default, but only for a pane whose agent reported a session reference through an official integration or its own resume command.

T3 Code takes a third road: pressing Resume in an empty composer continues a limited or interrupted turn by hand, and a continuation scheduled for a limit reset that fell while the app was down is resumed when it comes back.

One machine, or several

Both reach past one computer, in different shapes.

T3 Code puts its server on a machine and connects clients to it over T3 Connect, a LAN or Tailscale, with three machines linked free.

Herdr treats every machine you can SSH to as another place terminals live, and its terminals join the same list.

Who decides what the agent may do without asking

T3 Code has a real dial: Supervised, Auto-accept edits, Auto, and Full access, with Full access as the initial default, which is worth knowing before the first thread.

Herdr adds no dial of its own. It owns the terminal, so the agent's own prompts arrive as they would anywhere, and the app's job is to mark that pane as needing you.

The Herdr TUI goes one step further and reads the screen to decide when a real approval is showing.

How much of the app you can change

Both are open source, and they mean different things by it. T3 Code's answer is to fork it, and "Fork the whole thing" is on its front page.

Herdr's is to change the app you already run: the layout, sidebar, tabs, keys and themes are files an agent can rewrite for you, with a gallery of other people's layouts and mods to borrow from.

Which one should you use?

T3 Code fits if

  • You review agent code yourself and want the diff, the comments, the checks and the merge in one window.
  • You want a task to get its own branch and working directory without thinking about it, and to have the copies cleaned up afterwards.
  • You want the same threads on a laptop, in a browser and on a phone, and three linked machines is enough.
  • You already pay for a subscription or two and want one surface over all of them, plus an MCP door for agents you start elsewhere.

Herdr fits if

  • Your agents should keep working after you close the window, and you do not want to think about a server process to get that.
  • Your work is spread over a laptop and servers you reach over SSH, and you want them in one list.
  • You want status to come from the agent rather than from a screen, and you are content that a quiet agent shows no state.
  • You would rather reshape the app with your agent than wait for a feature request.

Neither, if what you want is a session list

If neither shape fits, there is a third option. Omniscio is the desktop app we make, and it sits between the two: a window you open, like T3 Code, with the session list as the centre of it, and sessions that keep their own state rather than a terminal's.

  • Any model, any harness — Claude Code, Codex, OpenCode, Devin, Pi, and Hermes all supported. It runs many sessions at once across projects and floats the ones waiting on you to the top.
  • Worktree isolation is off by default; it gives a session its own branch and working directory, and you turn it on per session, per project or for the whole app.

Engines whose tools run outside Claude Code's guardrail hooks are isolated by default in a git project: Gemini, Grok, Antigravity, OpenCode, Hermes, Pi, Kimi Code and DeepSeek Harness, and only a choice made for that one session overrides it.

  • There is a hard spending cap per session, which stops a session running on a pay-per-use API key when it reaches the limit; a session on a Claude Pro or Max subscription is never spend-capped.
  • It installs on Windows, macOS and Linux. The Free plan covers 8 projects, Pro is a paid plan billed monthly or yearly, and your AI usage is billed by the provider you already pay.

The features page lists what it does, the pricing page says what it costs, and the download page has the installers.

How we tested

Neither program was installed for this page, so the honest way to describe two programs we could not run is to say so and to quote their own documentation instead.

T3 Code will not start a thread without an authenticated provider, and neither it nor Herdr was installed here. Every statement about either tool rests on its own site, its own documentation, its own release page, and each one carries the date it was read and a link to where it came from.

Both projects move quickly. T3 Code's newest stable release when we looked was 0.1.7, published on 4 November 2026, four days before this page was checked, and the repository had been pushed to again that morning.

Herdr's terminal app was on 0.9.5, published on 14 October 2026, while the newer Herdr app had no published release yet.

Read the vendor's page before you rely on a copy of this page from a few months back, and if a step here does not match what you see, the vendor outranks us.

One thing this page cannot tell you is how either app feels to use, because nobody here used it. Where a claim would need a judgement, the sentence stays with what the vendor states and leaves the verdict to you: whether Full access is the right default, whether an opt-in status beats one read off the screen.

Sources

Every claim about another tool on this page rests on one of these, and the date beside each one is the day we read it.

  • T3 Code: the install guide, for what it controls, the provider table and what each one needs installed and signed in, the desktop and mobile apps, and the platform packages. Read November 8, 2026.
  • T3 Code: its site, for the control-plane line, the providers it orchestrates, the bring-your-own-subscription promise, the MIT licence and the free, open-source claim. Read November 8, 2026.
  • T3 Code: its FAQ, for the answer that it is not a harness, the statement that there is no way to pay it, the phone-as-a-remote line, the remote paths, and the free three-machine connect limit with what raises it. Read November 8, 2026.
  • T3 Code: its repository, for the organisation it is published under, its MIT licence and its language. Read November 8, 2026.
  • T3 Code: working with threads, for the new-worktree option, what a new thread inherits, how a thread continues in an existing worktree, and Resume in an empty composer for a limited or interrupted turn. Read November 8, 2026.
  • T3 Code: project settings, for where new worktrees go, the order settings resolve in, and the opt-in rules for cleaning up worktrees. Read November 8, 2026.
  • T3 Code: source control, for the hosts it connects to, the turn and branch diff views, pull-request review and merge, auto-merge, review guides and the pull-request watch. Read November 8, 2026.
  • T3 Code: permission modes, for the four modes and the initial default. Read November 8, 2026.
  • T3 Code: remote access, for T3 Connect, LAN pairing and Tailscale, the host having to stay reachable, what closing the last window stops, and the machine limit. Read November 8, 2026.
  • T3 Code: running in the background, for the service being Linux and macOS only and what installing it does. Read November 8, 2026.
  • T3 Code: outside agents, for the MCP server, the agents it admits and the access levels you choose between. Read November 8, 2026.
  • T3 Code: usage and limits, for what the Usage view combines and the warning that its cost figure is an estimate. Read November 8, 2026.
  • T3 Code: its latest release, version 0.1.7 on 4 November 2026. Read November 8, 2026.
  • Herdr: the Herdr app page, for agents running in herdr-core, the app reshaped by asking, the gallery counts, the status rule, SSH machines, what a quit and a reboot each do, the three Apache-2.0 programs and the platforms. Read November 8, 2026.
  • Herdr: the herdr-core page, for the runtime, the hc commands, agents starting and steering helpers, SSH machines joining one list, OSC 7501 as the only source of status, and the OpenRPC API. Read November 8, 2026.
  • Herdr: the download page, for the per-platform builds, the app setting up herdr-core for you, the plain files your agent can rewrite, and the free, open-source line. Read November 8, 2026.
  • Herdr TUI: the terminal app page, for the 22 detected agent CLIs, reading every pane, the platforms it lists, the install lines and the version. Read November 8, 2026.
  • Herdr TUI: session state and restore, for what a detach, a server restart and a live handoff each keep, and native agent session restore being on by default. Read November 8, 2026.
  • Herdr TUI: the Windows page, for the beta naming its URL still carries. Read November 8, 2026.
  • Herdr: the app guide, for one worktree per issue opening a new space for the branch nested under its repo, and Herdr TUI: the worktree settings, for a new worktree making a checkout from a Git workspace row, opening it as a workspace grouped under the source, and Delete worktree checkout running git worktree remove, and the CLI reference, for herdr worktree list, create, open and remove. Read November 8, 2026.
  • Herdr: the documentation index, read in full for this page, for what Herdr documents and what it does not. Read November 8, 2026.
  • Herdr: its latest release, version 0.9.5 on 14 October 2026. Read November 8, 2026.
  • Omniscio: the features page, for concurrent sessions, the engines, needs-you sorting, the hard per-session cap and its subscription exemption. Read November 8, 2026.
  • Omniscio: the pricing page, for what the Free plan covers, what Pro adds, and AI usage billed by your provider. Read November 12, 2026.
  • Omniscio: the download page, for the platforms it installs on. Read November 8, 2026.
  • Omniscio: the homepage, for the owner-approved line naming the harnesses. Read November 8, 2026.
  • Omniscio: the session isolation page, for isolation being off by default, the per-session, per-project and app-wide cascade, and the eight engines whose sessions isolate by default, and the features page for the cascade named in one line. Read November 8, 2026.
  • Omniscio: the cost control page, for the caps that apply only to pay-per-use API keys and the line that they never limit flat-fee Claude Pro/Max subscription sessions. Read November 8, 2026.

Common questions

Is T3 Code or Herdr better for running several coding agents?

They answer different questions. T3 Code is a client you open: it drives the agent CLIs you already own, gives a thread its own git worktree and diff, and lets you review and merge a pull request without leaving the app. Herdr is a runtime with a client on top: the agent processes live in its server, so they keep running when you close the window, and machines you reach over SSH sit in the same list. If the work ends in a reviewed pull request, T3 Code carries it. If it ends with agents still working while you are somewhere else, Herdr carries that.

Does T3 Code keep running when I close it?

No, not out of the box. Closing the desktop app's last window stops its local server. On Linux and macOS you can install a background service with t3 service install, and a Windows host has to keep t3 serve running in a terminal. The machine hosting the agents has to stay awake and reachable for your phone or browser to reach it.

Does Herdr review code or open pull requests?

Not on its own. Herdr's own pages and its documentation describe terminals, panes, agents, sessions, machines and Git worktree checkouts; they document no diff review or pull-request flow. The reviewing stays with whatever you run alongside it, or with the agent itself in its terminal.

Can I use T3 Code and Herdr together?

Nothing stops you, because they sit at different levels. Herdr owns terminal processes; T3 Code drives provider CLIs, which is a process Herdr could just as well be holding. But neither project documents an integration with the other, so treat any arrangement as yours to build rather than something either vendor supports.

Which one is free?

Both. T3 Code itself is MIT licensed and says there is no way to pay it; T3 Connect, the service that links your machines, is free for up to three, with more behind a paid T3 Chat plan. Herdr's app, herdr-core and Herdr TUI are Apache 2.0. Neither supplies the model: T3 Code does not resell tokens, and Herdr holds terminals for whatever agent you already run. You still pay Anthropic, OpenAI or whoever runs the account behind that agent.

Other tools worth a look

T3 Code and Herdr are two answers to the same question, and neither is the only one. The comparison hub puts the rest of them in one table: where each one runs, how it keeps sessions apart and what it costs.

Run many Claude Code sessions in parallel

Omniscio installs on Windows, macOS and Linux, and gives each session its own branch and working directory once you switch that on. The Free plan covers 8 projects, and Pro is a paid plan billed monthly or yearly.