Super-agent Architecture: Four Engineering Pillars for Truly Autonomous AI Agents

The author reflects on the Dsh product team's Super-agent design exploration, arguing that when AI model capability is no longer scarce, the product differentiator becomes managing complexity and freeing user attention.

Core Pain Points of Current Agents

Humans can only track 3–5 active sessions. In the classic ReAct loop, a synchronous run() tool call blocks the loop until the tool returns, preventing any new user input during that wait. Once a device sleeps or goes offline, the agent stops and cannot access other devices' environments.

These constraints limit single-task throughput to model ability and multi-task throughput to human attention.

Super-agent Paradigm: Four Characteristics

The Dsh team defines a Super-agent as a continuous entity that breaks the binding between an agent and a single manual session, preserving context across sessions while advancing multiple complex tasks concurrently without interference.

3.1 Continuous: Cross-Session Context Continuity

Technical implementation:

Use Thread (event stream per PR/topic) to merge scattered cross-channel conversations into one continuous context.

Organize context with Inline & Spill : high-frequency data stays in-window (cache), low-frequency spills to external storage.

Retrieve history via Chain of Recall — multi-hop retrieval along a "reference graph" to recover old task context.

Inspiration: OS and compiler cache locality and memory-tier management — treat the context window as a controlled cache: hot data resident, cold data evicted, on-demand multi-hop recall.

UX principle: User attention should not be spent checking "does Session X contain Y?"; the system flattens session boundaries so the user always faces "the same agent."

3.2 Efficient: Concurrent Response & Low Latency

Technical implementation:

Router uses a lightweight model only for interaction intake and task dispatch, not execution, avoiding a global bottleneck.

Batching aggregates events; experiments show at 40 triggers/minute, single-decision inference drops from 6.4 s to 1.6 s.

Worker contexts are isolated and run concurrently; subscribed events take a Fast Path straight to Workers, bypassing the Router — routing adds ~37% overhead.

Inspiration: Distributed-systems fast/slow path separation and batch scheduling: Fast Path uses deterministic logic to filter and pass through; Slow Path invokes the LLM for semantic judgment.

Design trade-off: Accept "more tokens for shorter, more stable latency" — separate cheap "should we act?" from expensive "how to act?".

3.3 Proactive: From Passive Window to Autonomous Collaborator

Technical implementation:

Shift from user-typed prompts to event-driven triggers: group chats, emails, CI results, etc., become TRIGGERs .

Two-lane event filtering: Fast Path (deterministic programmatic denoising) + Slow Path (LLM semantic "worth handling?" judgment).

Speculative execution : during background quiet periods, attempt feasible actions (e.g., submit a fix PR while a group discusses it) without waiting for explicit user instruction.

Inspiration: CPU speculative execution and event-driven/interrupt mechanisms: the system is "triggered by external events instead of spinning idle," and at high confidence "execute first, confirm later."

Goal: Transform the agent from a passive chat window into a collaborator that observes, advances work, and "stays quiet when intervention isn't needed" — moving the human role up to decision and acceptance.

3.4 Persistent: Always-Online & Self-Recovery

Technical implementation:

Compute-state separation : Agent Loop runs in cloud stateless elastic containers; Session state lives in a database, decoupled from single-machine lifecycle.

Compute-environment separation : Loop in cloud, heavy-state environment stays local; edge runs only a lightweight session-less daemon, supporting BYOM (Bring Your Own Machine) .

Watchdog : An independent external Control Loop periodically drives health checks — monitors infrastructure liveness and uses a model to detect "stuck in futile loops or goal drift," intervening via natural language.

Inspiration: Distributed-systems compute-storage separation and Anthropic's "decoupling the brain from the hands" — the environment is hard to replicate, so put the "brain" in cloud, leave the "hands" on-prem. Watchdog borrows the external control-loop idea: a primary system cannot self-detect drift; an independent loop must backstop it.

Outcome: Always online, plugged into real work environments, auto-recovers from anomalies — a long-lived digital collaborator.

Conclusion

The four traits — continuous, efficient, proactive, persistent — are not new inventions; they are classic engineering ideas (cache locality, fast/slow paths, speculative execution, compute-storage separation) applied to agents. The differentiator is whether you think of them and dare to use them. The author echoes Stephen Chow: "If a person has no dreams, what's the difference from a salted fish?" — push complexity down into the system layer, give attention back to humans, and grow agents from passive chat windows into always-online, understanding, and quietly competent digital partners.