The deep-agent harness: ReAct, sub-agents, memory & HITL

Ask a chatbot to build something real and you quickly hit its ceiling. It answers your message, forgets the plan, loses the thread halfway through, and confidently hands you code that doesn’t run. The problem isn’t the model — it’s the loop around it. Or rather, the absence of one.

A harness is that missing loop. It’s a durable process that keeps working toward a goal across many steps: reasoning, taking an action, observing the result, and reasoning again — recovering from failure without a human re-prompting at every turn. It’s the substrate underneath every Vastvic build, whether you’re forging a single tool or a whole application.

A ReAct loop that plans

The core is a ReAct cycle: reason, act, observe, repeat. But before it dives in, the agent writes a plan as explicit todos. That small discipline matters enormously — long tasks stay on track, and every step becomes visible in the run ledger instead of buried inside a model’s hidden state.

The difference between a demo and a system is whether you can see what it decided, and why — step by step, after the fact.

Sub-agents in parallel

Hard problems don’t fit in one context window or one train of thought. So the lead agent decomposes the work and spawns specialists — research, architect, coding, review, ops — that run in parallel and stream their results back.

Each sub-agent works in its own isolated context, which keeps the lead focused and the work fanned out instead of serialized. A research agent can be reading docs while an architect drafts the interface and a coder scaffolds files — then their outputs are reconciled.

Memory & context compaction

Real tasks outgrow any context window. The harness manages this by compacting its own history — summarizing what happened, keeping the load-bearing facts, and checkpointing durable state to disk. A build that spans hundreds of steps survives restarts and never loses the plot.

This is the unglamorous engineering that separates a toy from something you can trust with a multi-hour job.

Tools, MCP & human-in-the-loop

An agent is only as capable as the actions it can take. The harness gives it shell, file edits, web access, SQL — and, crucially, any MCP server as a first-class, governed tool. Adding a capability is mounting a tool, not rewriting the agent.

Power like that needs brakes. Risky actions — executing commands, writing files, deploying — pause at a human-in-the-loop interrupt for approval. Autonomy, but never unaccountable autonomy.

Self-verification

Finally, the loop closes on itself. It runs the build and its tests, reads the failures, and feeds them back in — retrying until the checks are green. The output isn’t “probably right”; it’s verified against tests the agent watched pass.

---

Put together — planning, parallel sub-agents, durable memory, governed tools, HITL, and self-verification — you get an agent you can hand load-bearing work to, precisely because every plan, tool call and decision is recorded and replayable.