TinyFish Breaks Down Agentic Search Architecture: A 7-Stage Production-Grade Design

Agentic Search is moving from research prototypes to production systems, but making AI agents reliably retrieve, reason, and deliver usable results in real-world environments remains an engineering challenge. TinyFish recently published two engineering research articles that break down the design tradeoffs of its agentic search approach from two angles: production architecture and deep research systems.

7-Stage Production Architecture and Evidence Contracts

According to TinyFish's first article, its production-grade agentic search architecture is divided into 7 stages, with "evidence contracts" and "bounded retries" as the core mechanisms. Evidence contracts require the agent to produce verifiable evidence at each stage rather than just conclusions; bounded retries set an upper limit on recovery attempts after retrieval failures, preventing the agent from looping endlessly down invalid paths.

This design addresses two typical risks when agentic search is deployed: first, agent outputs lack traceable grounding; second, error accumulation causes tasks to spiral out of control. Encoding evidence and retry boundaries into the architecture means the system constrains agent behavior at the engineering level, rather than relying on soft guidance through prompts.

Agentic Search refers to a search paradigm in which an LLM agent with reasoning and tool-calling capabilities autonomously drives the retrieval process, as distinct from traditional keyword matching or vector recall: the agent decides for itself how to rewrite queries, which tools to invoke (web scraping, APIs, databases), when to stop, and how to adjust its next action based on intermediate results. It typically involves multiple rounds of "think-act-observe" loops, so the requirements for controlling latency, cost, and error accumulation are far higher than in single-turn retrieval. The main challenges in production environments include: recovery strategies when tool calls fail or return empty results, context management in long-chain tasks, and how to make the final output auditable and reproducible. TinyFish's 7-stage architecture is precisely aimed at these engineering constraints, splitting a single search task into pipeline stages with clear boundaries so that the inputs and outputs of each link can be monitored and verified.

Bounded Retries is a common reliability pattern in distributed systems and agent engineering: for operations that may fail (here, retrieval, web scraping, tool calls), it sets an explicit cap or budget on recovery attempts, and once the threshold is reached, the system switches to a degraded path or terminates outright rather than looping indefinitely. Unlike simple "retry until success," the key is to explicitly model the retry budget and incorporate it into system state, making failures predictable and costs controllable. In agentic search, bounded retries also need to be combined with error classification—transient errors (timeouts, rate limiting) are worth retrying, whereas semantic failures (no results for a query, irrelevant pages) often do not benefit from retries and instead require query rewriting or switching data sources. TinyFish's decision to write bounded retries into the architecture layer essentially replaces soft prompt-level exhortations with engineering constraints, preventing the agent from burning large amounts of tokens and time on the wrong path.

Deep Research System Abandons the Standalone Planner

The other article explains a counterintuitive decision in TinyFish's deep research system: abandoning the standalone planner and per-query subagents.

In the traditional approach, a planner decomposes the task, subagents handle each query separately, and finally the system aggregates the results. TinyFish's engineering team found that in deep research scenarios, this layered structure introduces coordination overhead and information loss. After removing the standalone planner, the system internalizes planning capability into the main agent's reasoning process, reducing handoff costs between components.

This tradeoff shows that more complexity in agent architecture is not necessarily better. When the model itself has sufficient reasoning and tool-calling capabilities, an over-fragmented multi-agent structure may instead become a burden.

Planner is a classic component in multi-agent systems, typically handled by a dedicated LLM instance responsible for task decomposition: breaking the user's high-level question into sub-questions or subtasks, dispatching them to execution agents, and finally aggregating the results. This pattern originates from agent frameworks such as ReAct and Plan-and-Execute, and its advantages are separation of responsibilities and parallelizable subtasks. But the costs are also obvious—intermediate state must be passed between the planner and execution agents, and each layer of handoff may lose context or introduce misunderstanding; at the same time, the planner itself may make premature, rigid decompositions based on incomplete information that are hard to roll back later. Per-query subagents go a step further by assigning each sub-query to an independent agent, each maintaining its own context, which tends to produce fragmented information and duplicate retrieval during aggregation. TinyFish's abandonment of this structure essentially lets the main agent dynamically generate and adjust sub-queries within a single thread, so that planning and execution share the same context and handoff losses are reduced.

Implications for Production-Grade AI Agents

Together, the two articles point to a trend: the competitive focus in agentic search is shifting from "can it be done" to "can it be done reliably." Evidence contracts, bounded retries, and lean agent topologies are all engineering measures centered on reliability and operability.

For teams building production AI agents, TinyFish's practice offers design principles worth referencing: use architecture to constrain agent behavior, use evidence chains to support output credibility, and exercise restraint in multi-agent decomposition. Whether these lessons can be generalized to broader search and research workflows still requires more real-world case validation.

Operability refers to a system's ability to be observed, diagnosed, debugged, and iterated in production environments; for AI agents, it also includes tracing the basis for each decision, reproducing the inputs and outputs of failed tasks, and adjusting behavior without retraining the model. It typically requires structured logging, stage-by-stage trace records, and replayable execution chains. The reason agentic search treats reliability as a more central metric than "can it be done" is precisely that once a non-deterministic agent makes an error, troubleshooting costs are extremely high without observable intermediate evidence. Evidence contracts are, in a sense, also an operability design: the evidence produced at each stage both supports output credibility and serves as material for post-hoc auditing and regression testing.

One-line Summary

TinyFish publishes two studies proposing a 7-stage agentic search architecture and a lean deep research system design.

Paragraph Summary

TinyFish published two engineering research articles breaking down its production-grade agentic search approach. The first proposes a 7-stage production architecture whose core mechanisms are "evidence contracts" and "bounded retries": the former requires the agent to produce verifiable evidence at each stage rather than just conclusions, while the latter caps recovery attempts after retrieval failures to prevent endless looping down invalid paths—addressing the two major deployment risks of untraceable outputs and error accumulation. The second explains a counterintuitive decision in its deep research system—abandoning the standalone planner and per-query subagents and internalizing planning into the main agent's reasoning to reduce coordination overhead and information loss from component handoffs. Together, the two articles point to the same trend: the competitive focus in agentic search is shifting from capability validation to reliability and operability—using architecture to constrain agent behavior, evidence chains to support credibility, and restraint in multi-agent decomposition.