Analysis2026-11-13Updated 2026-11-13

DeepSeek Harness Adds Agent Teams. The Harder Problem Is Memory Between Sessions (Nov 2026)

TL;DRDeepSeek Harness v0.2.2-rc.2 adds per-session AgentTeam: team members and tasks in one panel, named sub-agents, and layered collaboration inside the same session. A separate experimental tool, subagent_oar, can hand independent tasks to a local Codex or Claude Code install. The Super-agent design behind it splits work into a Router that takes messages and dispatches tasks, and Workers that each run in their own session. Messages are grouped into threads by pull request or group chat topic, so a Worker can subscribe and receive later comments directly. Cross-session long-term memory is not built in yet. Cui Tianyi, a member of the DeepSeek product team, says it may be close. The unsolved part is not storage. It is deciding which decisions to keep and when to bring them back.

By Cameron Voss and West Mao

On this page
  1. What actually shipped, and what is still a prototype?
  2. Why is it called a Super-agent and not a sub-agent?
  3. The problem this architecture is trying to solve
  4. How does the Router and Worker split work?
  5. Why is cross-session memory the harder problem?
  6. What can you use today?
  7. What engineering work is still missing?
  8. What should developers watch next?

Two different things arrived in the same news cycle, and mixing them up leads to wrong expectations.

What actually shipped, and what is still a prototype?

The shipped item is v0.2.2-rc.2, a preview release on November 11. It supports opening AgentTeam per session, shows team members and their tasks on one panel, lets sub-agents carry names, and supports layered collaboration. This is available to users of the preview build.

The prototype is the Super-agent architecture itself. According to the team's own account, the internal version runs only in a small trusted environment inside the company. The part they call compute and state decoupled from the runtime environment still needs a lot of engineering work before it reaches a normal Harness install.

There is also subagent_oar, an experimental tool from late October. It does not create a teammate inside Harness. It hands an independent task to a local Codex or Claude Code process and lets that process do the work.

So the accurate description of this week is: the visible team UI is in preview, the orchestration theory is documented, and the durable execution layer is not done.

Why is it called a Super-agent and not a sub-agent?

The naming comes from a small analogy. In English typography, a superscript sits above the baseline and a subscript sits below it. A sub-agent is another layer underneath the agent that is already working. A Super-agent is a layer above it.

That sounds like branding, but it points at a real architectural difference. A sub-agent is a worker you spawn to do a piece of a task. A Super-agent is the thing that decides which tasks exist, which worker owns each one, and what happens when two tasks touch the same decision.

The distinction matters because a layer above needs a different kind of state. Workers can forget things; the layer above has to remember what is in flight.

The problem this architecture is trying to solve

The team's internal example is worth restating in full, because it is a normal developer day rather than a benchmark.

A developer asks an agent in a group chat to change code using plan A. The agent opens a pull request. Later, in a comment on that PR, the developer says to use plan B instead. A person reading the thread understands immediately that the comment modifies the earlier decision. The system has to connect the group message to the PR in front of it, then deliver the new plan to whichever agent is still editing code.

Every session layout fails at a different point.

Scroll horizontally to see all columns.

Session layoutWhat worksWhere it breaks
One session for everythingThe agent can see how the plan was chosen and revisedLogs, instructions and results pile into one context, and unrelated tasks queue behind each other
One session per taskWork runs in parallelTwo tasks that share a decision cannot see each other, and a comment in a third place has no route to the right session
Manual windowsNothingThe developer becomes the message bus, copying context between windows

That is the trade-off Cui describes: split the sessions and tasks run in parallel, split them far enough and the original context stops connecting. The two-layer design is an attempt to get parallelism without turning the developer into a router.

How does the Router and Worker split work?

The upper layer is a Router. It receives messages, dispatches tasks, and handles coordination between tasks. The lower layer is a set of Workers, each running in an independent session.

The user keeps working the way they already do: ask in the group chat, comment on GitHub. The system finds the Worker responsible for that piece of work and delivers the message.

Scroll horizontally to see the full figure.

Router receives messages and dispatches tasks to Workers over shared threads
The Router handles new tasks and coordination. Once a Worker subscribes to a thread, later messages in that thread reach it without another pass through the Router.

The piece that makes this workable is the thread. Instead of routing every message, the system groups messages that belong to the same pull request or the same group chat topic. The first message is dispatched by the Router. The Worker takes the task and subscribes to the thread. New comments on that PR then go straight to the Worker.

After that, the Router mostly handles new tasks and the cases where several pieces of work have to agree. It stops being a message bus and becomes a scheduler, which is the only way the saved time is not spent waiting on a central hop.

Why is cross-session memory the harder problem?

Routing works when there is an object to route by. A PR URL is an address. A group chat topic is an address. Once the PR is merged and a week passes, the address is gone.

Then the developer opens a new session and says to continue with the plan from last time. For that sentence to work, the system has to resolve three things: which project, which discussion, and which decision was actually final. The first is usually recoverable from the workspace. The second and third are not.

Cui is direct that the industry has no consensus on how to build long-term memory for agents. The two-layer design is partly a response to that gap. The Router can maintain relationships between tasks, and each Worker can keep the context its own execution needs. Neither layer answers the policy questions.

What is worth remembering after a session ends? A rejected design is often more useful than an accepted one, because it prevents a repeat. A one-off workaround should probably be forgotten. When should an old decision come back? Retrieval on every turn would poison the context with stale choices. Retrieval only on request means the agent will not notice that a decision exists.

Those are product decisions as much as model decisions, and they are why the feature is described as close rather than shipped.

Practical consequence for teams: until cross-session memory exists, keep decision records outside the session. A short decision log in the repository costs little and survives every window you close.

What can you use today?

In the preview build, AgentTeam is real and scoped to one session. You can see which agent is doing which task, name sub-agents, and check layered collaboration in a single panel. For multi-file work where you want to watch several workers at once, that already removes the guesswork of reading raw event logs.

Cross-session recall is not available. Reopening the window and asking for the previously agreed plan will not work unless the decision happens to be inside the new session's context.

The external handoff tool is also usable, with the caveat in its name. subagent_oar is experimental and depends on a local Codex or Claude Code installation. It is a way to borrow another agent runtime, not a way to give Harness a memory.

What engineering work is still missing?

The team names the decoupling of compute and state from the runtime environment. That is the requirement for an agent to survive a closed window, a restarted host, or a machine change. It is also what makes a Router meaningful across sessions rather than within one.

Durable execution brings its own hard cases: a call that was in flight when the process died, a tool with side effects that may already have run, a Worker whose context was trimmed during a retry. The team's own account says the internal prototype handles a small trusted environment, which is the right place to learn those cases before a public rollout.

What should developers watch next?

  • The move from rc to a stable AgentTeam release, and whether team panel state survives a restart.
  • Whether named sub-agents get stable identities, since a memory system needs a subject to attach decisions to.
  • Any documented retention policy. Without one, memory is just a longer context window.
  • Whether the Router becomes configurable. Different teams will want different dispatch rules.

Frequently asked

Is AgentTeam available in the stable DeepSeek Harness build?

It appears in v0.2.2-rc.2, which is a preview release. Treat it as testable, not as a guaranteed interface. Preview builds can change between releases.

Does the Super-agent replace sub-agents?

No. It adds a coordination layer above them. Sub-agents still do the work; the layer above decides which work exists and who owns it.

Can Harness remember a decision from a previous session?

Not yet as a built-in feature. The team says it may be close, but has not shipped a cross-session memory system. Until then, keep decisions in the repository.

Can I use my own Codex or Claude Code install as a worker?

That is what subagent_oar does, within its experimental limits. It is a task handoff, and it requires the other tool to be installed locally.