Hermes Agent vs T3 Code: Persistent Lessons or Portable Threads?
Compare Hermes Agent and T3 Code on memory, portable context, scheduled work, pull request watches and execution ownership.
Founder, Task Machine
Hermes Agent and T3 Code ask a developer to make a specific context decision: should the agent carry a corrected lesson into later work, or should an existing coding conversation move between providers and restarts? Both retain context, but the published mechanisms preserve different material.
The distinction becomes practical when you switch agents halfway through a fix or start a similar job next week. A portable conversation can preserve the current task's history. An editable memory note can preserve a preference beyond that individual task.
Hermes Agent builds a reusable memory
Hermes Agent's memory guide describes persistent notes and user preferences available in later sessions. You can inspect and edit that material through commands or the desktop panel. A repeated correction can therefore have a visible home outside the conversation where you first made it.
It also organizes delegated work through a profile board. The Kanban documentation gives an orchestrator profile a root card and specialists their child cards, with dependencies, comments and attempt history. The orchestrator judges completion and can add missing work.
People can comment and manage cards, but the published assignee is a profile name. The board follows a trusted local-user model and is single-host by design. If you need a shared human ownership record, evaluate that boundary explicitly before choosing the board for a team's work.
T3 Code carries the current conversation
T3 Code controls coding agents on computers you manage. Its thread guide describes separate threads, optional worktrees and delegated subagents. That gives you a place to follow an individual coding job and its conversation.
The portable handoff guide explains how selected conversation history can travel across providers or restarts. Agents can retrieve omitted messages. Handoffs exclude the outgoing provider's reasoning, tool-call state and attachments, so moving a conversation does not preserve every piece of the outgoing runtime.
T3 Code's public pages do not describe an editable store of learned lessons that improves later independent tasks. Treat a successful handoff as continuity for the job being moved. For a repository convention that must apply to future work, decide separately where that convention will live.
Choose how a job becomes a plan
Hermes Agent can expand a rough chat request into a specification or dependency-linked tasks. Its Kanban configuration lets you disable automatic child promotion so you can review generated work before execution. That fits a job you want to divide into specialist responsibilities and judge as a whole.
T3 Code shows plans, questions and work in threads. Its published proposed-plan component lets you read, download or save a plan to the workspace. Its public pages do not describe a standing project, goal or team lead role that reviews and coordinates work.
Both products can therefore make a plan visible before implementation. Hermes Agent supplies documented profile-level coordination around the task tree. T3 Code's thread model suits a developer steering the current job and deciding when to save its proposed plan as an artifact.
Review authority and follow-up work
Hermes Agent's security guide covers shell approval modes and allowlists, plus ranked proposals mined from executed, approved commands. You choose which proposals to apply, and destructive command classes are excluded. A history of approvals can inform a reusable permission decision without applying it automatically.
T3 Code's permission guide places action and subagent approval requests in the parent conversation. Its initial default for new threads is Full access, which permits commands and edits without prompts. You can change the default or apply an administrator cap, and its public pages do not describe proposals derived from approval history.
For delivery follow-up, T3 Code's source-control guide documents pull request watches. Failed checks, review feedback and conflicts wake the agent, and watching continues after it pushes a fix. Its review guides are beta reading tours, which should not be treated as an independent second review of risky changes.
Hermes Agent has goal completion checks and independent review skills. Its cited pages describe opening pull requests and reading comments, but do not establish a review-feedback revision cycle. Choose the published mechanism that matches your bottleneck, whether it is deciding completion or continuing work after external review.
Keep recurring execution available
Hermes Agent's cron documentation describes scheduled jobs, with webhook events also able to fire jobs. Self-hosted agent-backed schedules require the gateway to be running. A scheduler tick skips those jobs when the gateway is down.
T3 Code's project settings provide scheduled tasks and webhook tasks with filters, target environments and models. Signatures can verify the sender. Runs can start new threads or reuse existing ones. Neither product's published recurring prompts should be confused with a defined branching process: Hermes Agent's workflow-template routing is unfinished, and T3 Code's public pages do not describe that kind of multi-step workflow.
The T3 Code FAQ says the phone acts as a remote and the execution computer must stay on. Software costs $0, provider charges are separate, and T3 Connect is currently free for up to three linked machines. Hermes Agent's MIT core is free too, with optional Cloud plans listing Plus $20/month, Super $100/month and Ultra $200/month. The Cloud FAQ separately meters compute and storage and excludes inference and tools, without explaining the connection to included plan hosting.
Hermes Agent and T3 Code, point by point
The table gives both products the same questions, with a source and check date for each answer. It distinguishes conversation continuity, learned memory and the execution options each vendor publishes.
Both columns answer the same questions from each company's public pages. Yes means the company publishes the capability the question asks about, Partly means something narrower, No means it says it does not offer it, and Not published means its public pages do not describe it. Every answer links to its source and shows when we last checked it. The oldest check on this page was November 13, 2026.
| What you compare | Hermes Agent | T3 Code |
|---|---|---|
| Goals |
Hermes Agent
Partly
Persistent goals keep an agent working toward an objective, with a judge and optional completion tests. Its docs describe no linked metric tracking against an ongoing business goal. |
T3 Code
Partly
The /goal command keeps Codex, Claude or OpenCode working across turns until the agent judges the goal met, such as making tests pass. Its docs describe no linked metric tracking and goal-owner review. |
| Leads |
Hermes Agent
Yes
You can name an orchestrator profile to own a decomposed project's root task, assign child tasks to specialists, judge completion and add more work when needed. |
T3 Code
Not published
Its docs describe no named project, goal or team lead role that reviews and coordinates work. They describe parent threads delegating work to subagents. |
| Tasks |
Hermes Agent
Partly
Kanban cards keep an assigned agent profile, comments, dependencies and attempt history. People can comment and manage cards, but the documented assignee is a profile name rather than a person or an agent. |
T3 Code
Partly
Separate jobs use threads, with optional worktrees, conversation history and delegated subagents. Its docs describe no work-item ownership that can be assigned to either a person or an agent. |
| Recurring work |
Hermes Agent
Yes
Cron jobs run once or recur on a schedule, and webhook events can fire the same jobs immediately. Each job can carry its own instructions, skills and delivery settings. |
T3 Code
Yes
Scheduled tasks run once or repeatedly on a chosen environment, and webhook tasks start from outside events such as a new GitHub pull request. Runs can start separate threads or reuse one thread. |
| Workflows |
Hermes Agent
Partly
Kanban dependency chains coordinate roles such as scout, editor and writer. They provide ordered handoffs, but the kernel does not execute workflow templates, whose routing fields are reserved for a future version. |
T3 Code
Partly
Webhook tasks reuse a prompt with request placeholders and filters, and scheduled tasks repeat agent work. Its docs describe no defined multi-step process with branches that runs the same way each time. |
| Autonomy |
Hermes Agent
Yes
You configure shell approval modes, permanent allowlists and deny rules. Dangerous-command requests appear in the terminal or messaging chat, where you can approve or deny them. |
T3 Code
Yes
Per-thread permission modes choose whether commands and edits need approval, are accepted automatically or use the provider's automatic review. Requests, including subagent requests, appear in the parent conversation. |
| Learned autonomy |
Hermes Agent
Yes
The approvals suggest command mines executed, approved commands into ranked allowlist proposals. You choose which entries to apply, and destructive command classes are excluded. |
T3 Code
Not published
Its docs describe no proposals to change agent permissions based on your approval history. Permission modes and administrator caps are configured settings. |
| Memory |
Hermes Agent
Yes
Persistent notes and user preferences carry into later sessions. You can inspect, edit or delete learned memory through the journey commands or the desktop panel. |
T3 Code
Partly
Portable handoffs carry saved conversation context across providers and restarts, and agents can retrieve omitted messages. Its docs describe no editable lessons store that improves later independent tasks. |
| Planning |
Hermes Agent
Yes
From chat, Kanban can expand a rough idea into a specification or dependency-linked tasks. You can disable automatic child promotion so the generated tasks wait for manual review before execution. |
T3 Code
Yes
Threads display agent plans alongside their questions and work. The published client includes a proposed-plan card that you can read, download or save to the workspace, rather than leaving the plan only in chat text. |
| Intake |
Hermes Agent
Yes
Signed webhooks turn outside events into agent prompts. A route can target a named profile when profile multiplexing is enabled, and filter which events start work. |
T3 Code
Yes
Webhook tasks receive outside requests and route their rendered prompts to a configured project, model and environment. Filters select matching requests, and signatures can verify the sender. |
| Connectors |
Hermes Agent
Yes
A curated Model Context Protocol catalog and custom local or remote servers connect external tools. HTTP webhook routes accept signed service events and can post responses back through integrations such as GitHub. |
T3 Code
Yes
Outside assistants can connect through a Model Context Protocol (MCP) server with chosen access permissions, and webhook tasks receive service events with custom prompts and filters. |
| Models |
Hermes Agent
Partly
You choose the main model and can override auxiliary tasks. Provider routing chooses a backend for a selected model, rather than selecting a model from each task's needs. |
T3 Code
Partly
You can switch models during a thread and set a project's default model. Its docs describe manual selection and remembered defaults, not automatic model selection per task or step. |
| Cloud or your own computer |
Hermes Agent
Yes
Run the free agent locally through its desktop or terminal interfaces, or choose the optional Hermes Cloud service for a hosted instance with a persistent workspace. |
T3 Code
Partly
Agents run on your desktop, server or virtual private server, controlled through desktop, web or phone clients. Its docs describe no T3-managed execution computer. The phone is a remote, and your computer must stay on. |
| Your own subscription |
Hermes Agent
Yes
Hermes accepts your provider API keys and a ChatGPT account login. Its Claude account path requires Max plus purchased extra-usage credits, not the included Max allowance. |
T3 Code
Yes
T3 Code uses the coding agents you are already signed in to, including an existing Claude Code subscription. You can instead configure a provider instance with your own API keys and endpoint. |
| Pricing |
Hermes Agent
Yes
The MIT agent is free. Portal lists Plus $20/month, Super $100/month and Ultra $200/month, with credit top-ups. Cloud's FAQ separately meters compute and storage, excluding inference and tools, without explaining how that relates to included plan hosting. |
T3 Code
Partly
T3 Code does not resell tokens and charges $0 for the software. You pay the underlying provider separately. T3 Connect is currently free for up to three linked machines, rather than a usage-priced software plan. |
| Correctness |
Hermes Agent
Yes
Goal completion contracts define verification criteria, and shell quality gates must pass before a goal completes. Kanban review also maps acceptance criteria to evidence and can return work for correction. |
T3 Code
Yes
Pull-request watches monitor checks and wake the agent when a check fails, required checks pass or review feedback arrives. The /goal command also supports an explicit target such as making a package's tests pass. |
For software work
| What you compare | Hermes Agent | T3 Code |
|---|---|---|
| Code review rules |
Hermes Agent
Yes
The pull-request review guide uses reusable review guidelines and remembered team conventions, such as required type annotations and database access rules, to check later diffs. |
T3 Code
Partly
Beta review guides read pull-request changes and accept project-specific instructions about emphasis and ordering. Its docs do not establish code review checks against configured repository rules. |
| Adversarial review |
Hermes Agent
Yes
A bundled pre-commit skill delegates security and logic review to a separate, diff-only reviewer in interactive sessions. Kanban's review skill independently verifies handoffs and keeps the reviewer from editing the implementation. |
T3 Code
Not published
Its docs describe no independent second review of risky changes. Beta review guides provide a reading tour, while permission modes govern whether an action needs approval. |
| Risk rating |
Hermes Agent
Not published
Its docs describe no change-level risk rating before merge. Optional residual-risk notes on Kanban handoffs and severity labels for individual review findings do not establish such a rating. |
T3 Code
Not published
Its docs describe no pre-merge risk rating for a change. A beta review guide can mark a stop Look closely when a maintainer needs to make a call. |
| Pull requests |
Hermes Agent
Partly
Agents can open pull requests through the GitHub CLI, and the bundled GitHub skill requires reading PR comments. The cited docs do not establish a review-feedback revision cycle. |
T3 Code
Yes
Agents can create and link real pull requests, then watch them for reviews, failed checks and conflicts. A watched thread wakes the agent on new feedback and stays active after the agent pushes a fix. |
A fact we cannot find or cannot check is left out, and prices can change after the date shown. Task Machine publishes this comparison and is an interested party. Hermes Agent and T3 Code are named only to identify them, and there is no relationship between the companies. Has something changed? Tell us.
Who each one suits
Pick Hermes Agent if editable persistent lessons and an orchestrator's profile-based task tree fit how you delegate. Its honest limit is unfinished workflow-template routing and a single-host board trust model.
Pick T3 Code if portable coding threads and pull request watches fit your hands-on development process. Its context transfer excludes some runtime material, and its remote clients still require your execution computer to stay on.
Where Task Machine fits
Task Machine stores inspectable lessons at several work scopes and keeps plans, discussions and runs on owned Tasks. Its Workflow builder adds defined steps, branches, human questions and verifier checks. Agents can run in Managed Cloud or on a Local Worker you control.
Task Machine is the wrong pick if your requirement is $0 agent-interface software on computers you already operate. Compare Task Machine vs Hermes Agent and Task Machine vs T3 Code, then take one recent handoff and list which context must survive the next provider change.