Agent architectures (comparison)
This page compares cutting-edge agent architectures on a Level 1 to 4 spectrum and explains where Agentron sits: it uses all four levels—Level 1 (chat/RAG), Level 2 (workflows), Level 3 (heap planner routing), Level 4 (heap, create tools/agents on the fly)—with cost control and debuggable topology.
Taxonomy: design-time vs runtime structure
Agent architectures sit on a spectrum from design-time (human-controlled) to runtime (model-controlled) structure:
| Level | Architecture | Who decides structure | Used in production | Agentron | Notes |
|---|---|---|---|---|---|
| 1 | ReAct + tools (orchestrator) | Human picks tools; model picks order | ✅ Yes (ChatGPT, Claude, Gemini) | Yes | Single agent, fixed tool set, dynamic tool selection/ordering. Thought to Action to Observation; cost control and loop limits are mandatory. Agentron uses this for chat and RAG (notebook and inline): one ReAct agent, fixed tool set, model picks order. |
| 2 | Multi-agent, static topology | Human designs graph and roles | ✅ Yes (LangGraph, CrewAI, DSPy) | Yes | Predefined roles and flows. Predictable and debuggable; dominant in production. Agentron uses this for workflows: human-designed graph, configurable rounds. |
| 3 | Multi-agent, dynamic routing | Model chooses which agents to invoke | ⚠️ Emerging | Yes | Model decides routing at runtime; more flexible, harder to debug. Agentron uses this in heap: the planner (LLM) chooses which specialists to invoke and in what order per request—model-chosen routing over specialists. |
| 4 | Recursive / self-building (RLM) | Model builds its own architecture | 🔬 Frontier research | Yes | Model writes agents/structure on the fly; less production-ready, high variance. Agentron uses this in heap: the system can create new tools and agents on the fly; structure and novel agents are model-determined at runtime. |
Where Agentron fits: Agentron uses all four levels of the taxonomy. Level 1 (ReAct + tools): chat and RAG, notebook and inline block chat (retrieve, cite, optional web search); single agent, model picks tool order. Level 2 (static topology): workflows, human-designed graph, configurable rounds. Level 3 (dynamic routing): heap, the planner chooses which specialists to invoke and in what order per request (model-chosen routing). Level 4 (recursive / self-building): heap, the system can create new tools and agents on the fly; structure and novel agents are model-determined at runtime. The runtime builds a DAG from the plan and runs it. Specialist definitions can be human-defined or model-created.
Reference: The design-time vs runtime taxonomy is widely discussed—e.g. A Taxonomy of Agent Architectures: ReAct to Recursive Language Models (Gordon, 2026) and the AI Agent Design Patterns catalog . For recursive/model-built architectures see the MIT Recursive Language Models paper (Zhang, Kraska, Khattab).
Orchestration patterns (multi-agent)
When you use multiple agents, orchestration pattern matters:
| Pattern | Description | Pros | Cons |
|---|---|---|---|
| Hierarchical (supervisor/worker) | Central supervisor decomposes and delegates | Good for compliance, clear ownership | Risk of bottleneck |
| Sequential pipeline | Linear handoff (e.g. research to analyze to write) | Good for document/review flows | Fragile to single failure |
| Parallel (ensemble) | Same task in parallel; aggregate results | Good for brainstorming, diversity | Higher cost, coordination |
| Event-driven (pub/sub) | Message broker; agents react to events | Good for high volume, real-time | More moving parts |
| Peer-to-peer (mesh) | No central coordinator | Resilient | Harder to debug |
Where Agentron fits: Agentron uses the hierarchical (supervisor/worker) pattern for heap: the planner delegates to specialists. That pattern can implement the others for agents (e.g. the supervisor can delegate in sequence, in parallel, or via events), so one orchestration style covers varied workflows. Internally, event-driven patterns are used for workflow execution, chat pub/sub, and the run queue; see Event-driven architecture.
Agentron: Without heap, chat and RAG use a single ReAct agent with tools. With heap, the planner outputs a plan (priorityOrder) and the runtime builds a DAG from it, running specialists by level (e.g. general, workflow, tools, knowledge). Heap is hierarchical with a model-assembled DAG per request and can create new tools and agents on the fly; workflows stay human-defined static topology.
Production and safety (2026)
Cutting-edge agentic systems need explicit controls:
| Concern | Guidance |
|---|---|
| Cost and loops | Unbounded ReAct loops cause runaway cost. Use max steps, loop detection, and tool-call budget. |
| Tool reliability | Flaky tools trigger retries and cost spikes. Tools should be well-specified and optionally guarded (timeouts, circuit breakers). |
| Handoffs | If multi-agent, treat handoffs as versioned contracts; validate at boundaries; transfer full context or clear summary. |
| Failure modes | Hallucination propagation, cascading failures, coordination failures. Use bulkhead isolation, timeouts, graceful degradation. |
| Provider-agnostic layer | Prefer one abstraction over provider-specific SDKs; support multiple LLMs and optional MCP for tools. |
Agentron implements max steps, bounded rounds in workflows, and a provider-agnostic runtime (OpenAI, Anthropic, Ollama, remote LLMs, MCP tools).
System-theoretic view (2026)
Agentic systems can be decomposed into:
| Subsystem | Role |
|---|---|
| Reasoning & world model | How the agent reasons (e.g. LLM). |
| Perception & grounding | How the agent gets real-world signal (e.g. RAG, search). |
| Action execution | How the agent acts (tools, code, APIs). |
| Learning & adaptation | Online learning, feedback loops (optional in v1). |
| Inter-agent communication | Handoffs, contracts (relevant when multi-agent). |
Agentron (v1): Strong on perception (retrieval, RAG) and action (tools, workflows); reasoning is the LLM. Learning and adaptation: auto-mode learning for created agents is supported; user-guided learning is possible for both the Agentron agent and created agents. Deep inter-agent protocols can be deferred until needed.
Where Agentron fits (summary)
- Chat / RAG (no heap): Level 1 (ReAct + tools). Retrieve, cite, optional web search; max steps and cost control.
- Workflows: Level 2 (static topology). Human-designed graph, configurable rounds.
- Heap (chat): Level 3 (dynamic routing)—planner chooses which specialists and in what order per request—and Level 4 (recursive / self-building)—system can create new tools and novel agents/architectures on the fly. The runtime assembles a DAG from the plan and runs it. Specialists include general (Q&A, web search), workflow, agent, tools, knowledge (connectors), improve_run, improve_heap, improve_agents_workflows; execution DAG and new tools/agents are model-built at runtime.
- No unbounded ReAct loops; yes to provider-agnostic LLMs and MCP.
Research & further reading
- Taxonomy (design-time vs runtime): A Taxonomy of Agent Architectures: ReAct to Recursive Language Models (Gordon, 2026). AI Agent Design Patterns: the practical catalog (Activo). A Practical Guide for Designing, Developing, and Deploying Production-Grade Agentic AI Workflows (arXiv, 2025).
- Recursive Language Models: Recursive Language Models . Zhang, Kraska, Khattab (MIT). Models that build their own architecture at runtime.
- ReAct and robustness: e.g. Autono (ReAct-based robust agents with adaptive decision-making, memory; arXiv:2504.04650 ).
- System-theoretic patterns: Agentic Design Patterns: A System-Theoretic Framework (NeurIPS 2025). Reasoning and world model, Perception and grounding, Action execution, Learning and adaptation, Inter-agent communication.
- Production patterns: LangGraph, CrewAI, DSPy for static multi-agent; OpenAI Assistants API, Claude tools for ReAct-style production.
For in-repo deployment and runtime boundaries, see the architecture doc in the repository.