Skip to content

RES/AGT · Research

AI Agents — reliable multi-step reasoning under real workloads.

Studying how agentic systems behave once tool counts grow, contexts get noisy, and reasoning chains exceed what a single loop can carry.

Research area AgentsComplexity HighSystem layer ReasoningOperational focus Reliability
§ 01Opening

Single-loop ReAct does not degrade gracefully as tool count grows. It collapses. Past six to eight tools, the reasoning loop is doing two incompatible jobs simultaneously: deciding what to do next and selecting which tool to use from an increasingly large candidate set. These are different cognitive operations. The first requires world-state reasoning; the second is a retrieval problem. Treating them as one operation, in one loop, means the quality of both degrades together — and the degradation is not visible step by step. Each individual step looks plausible. The failure only surfaces in the output.

This is not a prompt engineering problem. Cleaner tool descriptions help marginally; they do not eliminate the fundamental constraint that the reasoning loop has no mechanism for narrowing the candidate tool set before selection fires. The fix is architectural: separate tool routing from task reasoning. That decision has consequences that propagate through everything downstream — orchestration topology, memory management, evaluation surface, failure recovery strategy. None of those decisions are independent.

The research question is not whether single-loop architectures fail. They fail at scale — that is well-documented. The open questions are where the exact thresholds sit, how they shift across model families, what the correct topology looks like for different task shapes, and how to build an evaluation surface that catches reasoning failures before they reach the output layer. That is what makes this research rather than engineering.

§ 02What Transfers

Agent research inherits assumptions from both LLM prompting literature and distributed systems research. Some of those assumptions hold under real workloads. Others break in ways that are not immediately obvious because the failure mode is statistical rather than binary — the system appears to work until it reliably does not.

ConceptTransfers?Adaptation RequiredConfidence
ReAct loop as base architecturePartiallyWorks reliably with 3–5 tools. Collapses past 6–8 — tool selection becomes a retrieval problem the reasoning loop was not designed to solve. The loop has no mechanism for narrowing the candidate tool set before selection.Medium
Chain-of-thought reliability across multi-step chainsPartiallyCoT improves single-step reasoning. Across multi-step chains, reasoning errors compound — an incorrect intermediate conclusion propagates forward and is treated as ground truth by subsequent steps. No native self-correction mechanism exists.Low
Tool selection accuracy under scaleNoAccuracy degrades as tool count grows, even with well-written descriptions. Past a threshold, tool selection must be treated as a retrieval problem — narrow the candidate set before the reasoning loop fires. This is an architecture change, not a prompt change.Medium
Memory retrieval for long-horizon tasksPartiallySemantic retrieval against stored context works for discrete lookups. Agents do not naturally partition working memory from long-term stores — everything accumulates in context until the window fills. Explicit memory management must be layered on top.Low
Multi-agent trust boundariesNoInteroperability patterns are emerging for agent identity, transport, and authenticated communication, but semantic trust remains unresolved. An agent still needs a policy for deciding whether a peer agent's output is sufficiently verified before it can trigger consequential action. The attack surface and error-propagation surface remain closely coupled.Low
Step-level evaluationYesEvaluation can be applied at each step boundary. The constraint is that step-level metrics must be defined independently of final output quality — intermediate steps that are locally correct can produce globally wrong outcomes.High
Failure recovery and retryPartiallyRetry loops handle transient failures. They amplify reasoning failures — an agent that retried an incorrect reasoning path three times has compounded the error, not corrected it. Retry strategy must distinguish infrastructure failure from reasoning failure.Medium
Linear debuggabilityContestedSingle-loop ReAct produces interleaved reasoning and action traces. Inspecting what the agent was trying to do at step N requires reading the full trace to that point. Controller-worker topologies restore per-step observability by isolating reasoning to the controller and execution to workers.Medium

State of Understanding — RES/AGT · Agentic Architecture Primitives

§ 03Controller-Worker Topologies

The structural argument for controller-worker topology is debuggability, not raw capability. A single-loop agent with twelve tools is a system where every execution trace is an entangled mix of reasoning steps and tool calls. When the output is wrong, finding the step where the reasoning diverged requires reading the full trace — there is no architectural boundary that separates "what the agent was trying to decide" from "what the agent tried to do."

An explicit controller separates these concerns. The controller reasons about task decomposition and sub-task sequencing. It does not call tools directly. Workers execute discrete, bounded sub-tasks against a narrow tool set — two to four tools per worker, chosen for semantic coherence. The controller's trace contains only reasoning. A worker's trace contains only execution. When something fails, the failure is localized to one layer.

SINGLE-LOOP REACTCONTROLLER-WORKERAGENTT-01T-02T-03T-04T-05T-06T-077 TOOLS — SELECTION DEGRADESCTRLreasonWRKWRKWRKT-01T-02T-03T-04T-05T-062 TOOLS / WORKER — BOUNDED

Fig. RES/AGT — Agent Topology Comparison · Single-loop vs. controller-worker under tool scale

The cost of the controller-worker topology is coordination latency and architectural complexity. The controller must formulate sub-tasks with enough specificity that workers can execute them without re-querying for clarification. Workers must return results in a format the controller can integrate without disambiguation. Both of these constraints are interface design problems — the controller-worker boundary is an API, and it must be designed with the same rigor as any external API. The production readiness framework at FRM/04 treats interface stability as a readiness dimension — that framing applies directly here.

The topology decision also determines the evaluation surface available. A single-loop agent can only be evaluated at the output boundary. A controller-worker system can be evaluated at the controller's sub-task decomposition, at each worker's execution output, and at the final integration step independently. More evaluation surface means more signal about where failures originate — which is a prerequisite for fixing them. The evaluation pipeline at SYS-03 is designed to operate at step boundaries, but the step definitions depend on the topology of the agent being evaluated.

§ 04Tool-Use as Interface Design

Tool boundaries are not prompt engineering problems. They are API design problems. The agent's ability to call a tool correctly is a function of the tool's schema quality, input validation strictness, and error message specificity — not only of the description string attached to the tool definition.

A tool with a permissive schema accepts inputs that will produce wrong results without raising an error. The agent learns nothing from the call — the response looks valid, the result is incorporated into context, and the error surfaces three steps later when the downstream reasoning fails. A tool with a strict schema and informative validation errors gives the agent immediate, actionable signal: this input was wrong, here is why, here is the constraint it violated. That signal is usable by the reasoning loop in a way that a silent wrong result is not.

Error message design for agent-facing tools requires different choices than error message design for human-facing APIs. Human developers read error messages; agents parse them. An error message that says "invalid parameter" gives a human developer enough signal to check the documentation. An agent needs the constraint specified in the error itself — "date must be ISO-8601 format, received MM/DD/YYYY" — because it cannot follow a link to documentation. The tool is the documentation.

The second interface design problem is result cardinality. A tool that can return one record or ten thousand records depending on the query parameters is a tool with an unbounded output surface. The agent's context window is finite. A tool that returns a bounded, structured result forces the agent to make more specific queries — which is a better behavior pattern than prompting the agent to "be specific" in the system prompt. Constraints in the interface beat constraints in the prompt. The prompt is advisory; the schema is enforced.

Standardized interfaces are beginning to move some of this boundary out of bespoke orchestration code. The Model Context Protocol (MCP) provides a common way for agents to discover and use tools and data, while Agent-to-Agent (A2A) focuses on communication and handoff between agents. The durable architectural consequence is more important than either protocol name: stable interfaces reduce the amount of integration logic that has to live inside prompts. They do not remove the need for validation, authorization, or semantic verification at the boundary.

§ 05Agent Memory Taxonomies

Four memory types appear consistently in cognitive science and have direct analogs in agent architectures, though the mapping is imperfect and the engineering implications of each are still being worked out.

Working memory is the active context window — everything in the current prompt. It is fast, bounded, and volatile. Agents have no native mechanism for managing what enters or exits working memory; everything accumulates until the window fills. Long-horizon tasks require explicit working memory management: compression, summarization, and eviction of intermediate results that are no longer needed for the current step.

Episodic memory is a record of specific past task executions — what was tried, what succeeded, what failed. It is the most directly useful memory type for improving agent performance across runs, and the least commonly implemented. An agent without episodic memory repeats the same mistakes across sessions because it has no access to its own history. Implementing episodic memory requires deciding what to record, how to structure it for retrieval, and how to prevent past failures from being retrieved as candidate approaches.

Semantic memory is general knowledge about the domain — facts, relationships, and concepts that do not belong to any specific task execution. Vector stores are the dominant implementation. The retrieval quality problem is well-studied; the interference problem between episodic and semantic retrieval when they share a store is not. A query for a domain fact should not surface past task records, and vice versa. Store separation with a routing layer is the obvious architectural response — the routing decision itself is an open question.

Procedural memory is knowledge of how to perform tasks — the steps, the sequence, the decision points. In agent systems, procedural memory maps most directly to system prompts, few-shot examples, and hard-coded workflow templates. It is the memory type that changes slowest and costs most to update. An agent that learns a wrong procedure and embeds it in a system prompt will repeat that procedure indefinitely. Procedural memory requires version control, not just storage. The relationship between durable execution semantics from RES/ORC and persistent procedural state has not been worked out for agentic workloads.

§ 06Failure-Mode Catalog

Most agent failures are interface failures, not reasoning failures. The reasoning loop is making decisions based on the information available to it — if that information is wrong, ambiguous, or structured in a way that misleads the reasoning process, the output will be wrong even if every reasoning step is locally coherent. The catalog below represents recurring failure classes observed in production-adjacent agentic systems, with the control structure that contains each.

F01Tool selection drift

The agent selects a plausible but incorrect tool, receives a result, and incorporates the result into its reasoning without recognizing the selection was wrong. The error is invisible in the trace until the final output fails.

Control →

Narrow the candidate tool set before selection. Treat tool routing as a retrieval step, not a reasoning step.

F02Context saturation

Long-horizon tasks fill the context window with intermediate results. The agent's attention distributes across the full context — early task framing competes with recent results. Instruction following degrades as context deepens.

Control →

Compress and summarize intermediate results before they accumulate. Treat context management as an explicit lifecycle, not an implicit consequence of task length.

F03Reasoning loop without exit

The agent enters a self-consistent reasoning loop that produces plausible-sounding intermediate steps but never converges on a termination condition. Step count increases; output does not improve.

Control →

Hard step-count limits enforced at the executor layer, not the reasoning layer. The agent cannot be trusted to recognize its own non-convergence.

F04Compounding intermediate error

An incorrect intermediate conclusion is treated as ground truth by subsequent reasoning steps. The error does not surface in any single step — each step is locally plausible. The final output is wrong in a way that requires full trace reconstruction to diagnose.

Control →

Step-level evaluation checkpoints. Independent evaluation of each reasoning step output before it is committed to context.

F05Overly broad tool call

The agent calls a tool with parameters that are technically valid but semantically too broad — requesting all records instead of a filtered subset, or querying a search with an underspecified term. The tool returns a result that overwhelms subsequent context.

Control →

Tool schemas that enforce parameter constraints. Input validation at the tool boundary, not at the prompt level.

F06Silent partial completion

The agent completes some but not all sub-tasks in a multi-step objective, then signals completion without acknowledging what was skipped. The skip is not logged. The caller receives a success signal against an incomplete result.

Control →

Completion checklists generated at task start. Explicit sub-task tracking in the orchestrator, not in the agent's self-report.

The catalog is not exhaustive and is not intended to be. The value is in the pattern: most failures share a common structure — the agent receives a signal that is locally plausible but globally wrong, acts on it, and the error propagates forward invisibly. The control structure in each case is the same: move the constraint to an earlier boundary, make the failure loud sooner, or add an independent verification step that does not share the same context as the failing agent. The non-determinism of LLM outputs compounds all of these failure modes, as documented in RES/REL.

§ 07Open Questions

These are the questions where current understanding runs out. They are first-class content, not an appendix.

Contested

What is the reliable tool-count ceiling for single-loop architectures, and is it consistent across model families?

Empirical evidence points to degradation past 6–8 tools, but the threshold appears to vary by model, tool description quality, and task domain. Whether the ceiling is a property of the architecture or a property of current model training is not settled. If it is a training artifact, it may shift with future models — which means architectural decisions made against today's ceiling could be premature.

Unresolved

How should agents handle partial task completion on failure without losing the completed sub-task record?

Current agent runtimes treat task completion as binary — the task either completed or it did not. Partial completion has no standard representation. Durable execution as documented in RES/ORC provides checkpoint semantics for infrastructure failures, but semantic partial completion — the agent completed three of five sub-tasks before encountering an unresolvable decision — has no equivalent. No production pattern has emerged for persisting and resuming partial agentic work.

Active research

What is the correct evaluation surface for multi-step reasoning chains — step-level, trajectory-level, or outcome-level?

Step-level evaluation catches intermediate errors early but requires per-step ground truth. Trajectory-level evaluation assesses whether the reasoning path was efficient and correct, but requires a reference trajectory that may not exist for open-ended tasks. Outcome-level evaluation is the easiest to instrument but provides no signal about where in the chain the failure occurred. The relationship between these three surfaces and how they compose into a useful evaluation regime is an active investigation — adjacent to the open questions in RES/REL on non-deterministic output scoring.

Contested

When does controller-worker coordination overhead exceed the debuggability benefit?

Controller-worker topology adds latency and complexity: the controller must formulate sub-tasks, dispatch them, and integrate results. For simple tasks that a single-loop agent completes in two or three steps, the coordination overhead may exceed the benefit. The crossover point is not established — it is likely a function of task complexity, tool count, and the team's debugging requirements. A team that never needs to inspect intermediate steps has less reason to pay the coordination cost.

Unresolved

How should episodic memory be structured to support long-horizon continuity without polluting semantic memory?

Episodic memory — records of specific past task executions — has a different retrieval pattern from semantic memory — general knowledge about the domain. Mixing them into a single vector store produces retrieval interference: a query for domain knowledge surfaces past task records, and vice versa. Separate stores with a routing layer is the obvious solution, but the routing decision — when a query is episodic versus semantic — is itself a reasoning problem that has not been formally characterized for agentic workloads.

The questions resolve in a particular order and the order matters. The tool-count ceiling question is the most immediately answerable — it requires controlled measurement against a fixed benchmark, not operational data from a running system. It gates the controller-worker coordination overhead question, because the crossover point at which topology investment pays off depends on knowing where the single-loop ceiling sits. The evaluation surface question depends on topology being established first — the right evaluation checkpoints are a function of where the architectural boundaries are. Partial completion and episodic memory both depend on having a running system with observable failure modes — they require operational data to characterize, not thought experiments. The memory routing question is last because it depends on first distinguishing empirically which retrieval failures are caused by interference between memory types versus inadequate retrieval quality within a single type. Until the running system exists and produces failure data, the dependency structure is visible but the resolution path is not.