Paper deep dive
Self-Optimizing Multi-Agent Systems for Deep Research
Arthur Câmara, Vincent Slot, Jakub Zavrel
Intelligence
Status: succeeded | Model: google/gemini-3.1-flash-lite-preview | Prompt: intel-v1 | Confidence: 95%
Last extracted: 4/10/2026, 2:04:20 AM
Summary
This paper explores self-optimizing multi-agent systems for Deep Research (DR), proposing a framework where agents iteratively plan, retrieve, and synthesize information. The authors evaluate two prompt optimization methods, TextGrad and Genetic-Pareto (GEPA), demonstrating that these methods can automatically refine agent prompts to match or outperform expert-crafted ones, particularly when starting from minimal baselines.
Entities (5)
Relation Signals (3)
Deep Research System → utilizes → Orchestrator Agent
confidence 98% · In one possible architecture, an orchestrator agent coordinates the process
Prompt Optimization → improves → Deep Research System
confidence 95% · prompt optimization consistently improves performance relative to the minimal prompt baseline
GEPA → outperforms → TextGrad
confidence 90% · GEPA performs strongly across both prompt regimes... outperforming TextGrad in the minimal-prompt regime
Cypher Suggestions (0)
No Cypher suggestions yet.
Abstract
Abstract:Given a user's complex information need, a multi-agent Deep Research system iteratively plans, retrieves, and synthesizes evidence across hundreds of documents to produce a high-quality answer. In one possible architecture, an orchestrator agent coordinates the process, while parallel worker agents execute tasks. Current Deep Research systems, however, often rely on hand-engineered prompts and static architectures, making improvement brittle, expensive, and time-consuming. We therefore explore various multi-agent optimization methods to show that enabling agents to self-play and explore different prompt combinations can produce high-quality Deep Research systems that match or outperform expert-crafted prompts.
Tags
Links
- Source: https://arxiv.org/abs/2604.02988v1
- Canonical: https://arxiv.org/abs/2604.02988v1
Trouble viewing inline? Open PDF directly →
Full Text
31,443 characters extracted from source content.
Expand or collapse full text
Self-Optimizing Multi-Agent Systems for Deep Research Arthur Câmara, Vincent Slot, and Jakub Zavrel Zeta Alpha, Amsterdam, The Netherlands camara,vincent.slot,zavrel@zeta-alpha.com w.zeta-alpha.com Abstract. Given a user’s complex information need, a multi-agent Deep Research system iteratively plans, retrieves, and synthesizes evidence across hundreds of documents to produce a high-quality answer. In one possible architecture, an orchestrator agent coordinates the process, while parallel worker agents execute tasks. Current Deep Research systems, however, often rely on hand-engineered prompts and static architectures, making improvement brittle, expensive, and time-consuming. We there- fore explore various multi-agent optimization methods to show that en- abling agents to self-play and explore different prompt combinations can produce high-quality Deep Research systems that match or outperform expert-crafted prompts. 1 Introduction When tackling complex information needs that require structured long-form an- swers, hundreds of documents and dozens of queries may be needed before enough information can be acquired to produce the final answer. Further complicating matters, this process is highly iterative: the information gathered in one step informs subsequent queries and the research direction in later iterations. Such settings require retrieval systems to synthesize intermediate findings, identify knowledge gaps, and continuously formulate new queries. This paradigm, of- ten referred to as Deep Research (DR), moves away from the standard single- turn “retrieve-then-generate” workflow that is common in traditional Retrieval- Augmented Generation (RAG) [9]. Instead, DR systems rely on an agent that can issue multiple queries, inspect large numbers of search results, and reason over the acquired knowledge before repeating this process until it can produce a high-quality answer [7, 21, 13]. While reasonably successful, these systems remain heavily dependent on hu- man intuition and heuristic design. Most current DR systems rely on handcrafted architectures and verbose, static system prompts to guide agent behavior [11]. However, this approach is inherently brittle. A set of prompts that performs well for one Large Language Model (LLM) and one specific topic may fail when models change or when applied to a different field or research task altogether. When such changes inevitably occur, this typically triggers an expensive and arXiv:2604.02988v1 [cs.IR] 3 Apr 2026 2Arthur Câmara, Vincent Slot, and Jakub Zavrel What were the most used AI accelerators in 2025? Plan: I need to research about accelerators and how they differ to each other. Let’s start with Nvidia and Intel. Plan: I haven’t found information about Google’s TPUs or other accelerator vendors like Cerberas. Let’s search... 14 2 5 ArXiV papers that mention Nvidia GPUs [doc_2] and [doc_3] use A100s, but they are from January. [doc_4] uses H100s. [doc_10] and [doc_13] claim to use H100s. [doc_15] uses 4 V100s. Task:Identify what GPU each paper use. Intel AI hardware 2025 Intel has Xeon CPUs available for servers [doc_14, doc_56] Intel ARC GPUs are not CUDA compatible [doc_94] but good for AI-inference [doc_123] Task: What kind of AI hardware Intel has available? The H100 is the most popular Nvidia GPU for AI in 2025 [doc_4,doc_10,doc_13], with the A100 remaining popular [doc_2,doc_3]... Intel's Xeon CPUs are still one of the most commonly used hardwares for AI and Deep Learning[doc_14,doc_15] with ARC GPUs being... 3 Fig. 1. Architecture for a multi-agent Deep Research system:1an orchestrator agent (orchestrator) creates a list of tasks for the user’s question. Each task consists of a query and instructions. 2multiple reader agents (reader) inspect batches of doc- uments and extract the information requested in the task.3an aggregator agent (aggregator) combines these smaller information pieces into larger mini-reports for each task.4the orchestrator agent can decide whether to refine the plan with more tasks or5call a writer agent (writer), which combines all merged information into a long-form report. time-consuming round of trial-and-error [16], where developers manually tweak prompts and architectures until they reach a reasonable quality threshold [8]. Recently, it has been proposed to shift from manual “prompt engineering” towards a more algorithmic “prompt optimization” process. Such proposals— including GEPA [1], TextGrad [19], AutoPDL [16], GASO [17], GAPO [5], the Darwin-Gödel Machine [20], and topology optimization methods [22]—suggest that natural language prompts as well as other multi-agent system parameters and architectures can be treated as trainable parameters and optimized. By em- ploying feedback mechanisms, where the frontier LLM itself is the optimization operator, these systems can self-improve: prompts can be refined, agents can explore and self-play, and high-quality agents can be produced with minimal manual input [4, 6, 18]. In this work, we explore how these approaches, in particular TextGrad and GEPA, fare when applied to an industrial-scale DR system. We next intro- duce and discuss our multi-agent architecture for DR and show how a GEPA- inspired method can create high-quality agents that can outperform expert- crafted prompts. 2 A Multi-Agent Deep Research Architecture In general, Deep Research systems contain four main components [15]: (i) Query planning: decomposing the initial complex research query formulated by the system’s user into a series of simpler, manageable sub-queries; (i) Information acquisition: using external knowledge bases (e.g., a search engine) or other tools to gather relevant information as needed; (i) Memory management: maintaining Self-Optimizing Multi-Agent Systems for Deep Research3 and updating the context relevant to the task with the information already re- trieved; and (iv) Answer generation: producing comprehensive, source-attributed outputs, such as scientific reports or long-form answers. Our instantiation of a multi-agent DR system is shown in Figure 1. The num- bered callouts in the figure correspond to the main control flow: 1an orchestra- tor agent (orchestrator) produces an initial plan and a set of tasks (each with a search query and instructions); 2multiple reader agents (reader) retrieve and read documents in parallel and extract task-relevant evidence snippets;3an aggregator agent (aggregator) consolidates these snippets into task-level mini- reports; 4the orchestrator agent updates its state (what is covered vs. what is missing) and either issues new tasks or proceeds to writing; and5a writer agent (writer) produces the final long-form report with citations. In addition to these agents, our system includes orchestration and bookkeep- ing utilities (e.g., citation tracking, de-duplication, and cleaning) that support memory management and source attribution. We discuss our implementation in more detail in Section 4. Our Multi-Agent Deep Research system contains the following agents: Orchestrator. Given the user query, the orchestrator produces an initial plan for how to tackle the problem. It is composed of a natural language description of the plan and a list of tasks that the reader agents should accomplish. Each task contains (a) a search query (formulated as a tool call) and (b) a concise description of what type of information the reader agents should look for when inspecting retrieved documents. After each round of exploration and consolida- tion, the orchestrator agent analyzes the information collected so far and either refines the plan by issuing new tasks or stops and proceeds to the writer. Reader. For each task, the system retrieves a large number of documents (e.g., webpages, PDFs, or internal knowledge base entries or documents in an Enter- prise Search setting). Multiple parallel reader agents then analyze these docu- ments in batches, extracting task-relevant information according to the instruc- tions defined by the orchestrator. Each reader agent outputs citation-backed evidence snippets that can be traced back to the source documents (for later citation and de-duplication handling). This stage is designed for high recall, allowing hundreds of documents to be inspected in parallel. Aggregator. The aggregator agent combines the information extracted by all reader agents for a given task, producing a mini-report with the information re- quested by the orchestrator for that task. The intuition is that the aggregator agent can de-duplicate overlapping evidence extracted by multiple readers, rec- oncile or surface conflicts, and discard weak evidence. Writer. At some point, the orchestrator agent either decides that it has gath- ered enough information to produce a final report, or reaches a pre-defined limit of compute resources, and invokes the writer to generate the long-form report 4Arthur Câmara, Vincent Slot, and Jakub Zavrel by combining the information compiled in the mini-reports produced by the aggregator agents. Here, our system also handles citation insertion and pro- duces a final “References” section. Citation management. Throughout the pipeline, each piece of extracted evidence is tagged with a unique document identifier (i.e., a hash of its URL) linking it back to its source. The reader agents output citation-backed snippets using a consistent format (e.g., square-bracketed identifiers). The aggregator preserves these identifiers when merging information and de-duplicates overlapping evi- dence from the same source. Finally, the writer resolves all identifiers into a unified bibliography, ensuring that each claim in the final report can be traced to its provenance. 3 Self-optimizing Deep Research systems As discussed in Section 1, each agent in a Deep Research (DR) system typically contains a hard-coded prompt written by a human expert and tuned to a specific setting and domain. While this works well when the system is deployed in similar conditions, it makes the agents brittle to changes in the domain or model. For example, a DR system designed for chemical engineering may contain domain- specific terms and instructions that do not generalize to a biomedical setting. Similarly, changing the underlying model (e.g., from a closed-source LLM to a locally deployed LLM) can cause significant variation in the quality of the results produced by the system. Such changes lead to a long, difficult, and costly process of adapting individ- ual prompts to a new domain, model, or shifts in user behavior. The alternative we propose in this work, is to automatically optimize the multi-agents system, allowing the system to self-play and explore variations and combinations of agent prompts with minimal manual intervention. In this paper, we focus optimization of prompts, although all aspects of the multi-agent system (parameters, LLM models, system archtecture, etc.) can be optimized using the same principles. More specifically, we optimize a candidate system C = c o , c r , c a , c w using a training set D = (q i ,R i ) N i=1 , where R i = r i,1 , . . . , r i,K i . Here, c o , c r , c a , and c w are the system prompts for the orchestrator, reader, aggregator, and writer, respectively; q i is a training query; and R i is the set of rubric criteria used to evaluate candidate answers for q i . In each optimization step j, we select a system C from a pool of candidates and optimize one of the agents in C (e.g., c o ), selected in a round-robin fashion. We then sample a mini-batch B ⊂D and generate answers for its queries using C. The optimization process outputs an updated prompt for the selected agent, yielding a new candidate system C ′ j (e.g., c ′ o , c r , c a , c w ). We explore two optimization methods applied to the DR architecture dis- cussed in Section 2: Genetic-Pareto (GEPA) [1] and TextGrad [19]. While the two methods differ in their details, both follow a similar reflection-to-refinement pattern: the system’s outputs (and, optionally, execution traces) are fed into a Self-Optimizing Multi-Agent Systems for Deep Research5 “meta-prompt” that produces suggestions for improving the prompt of a chosen agent. The main differences lie in how they select a candidate system C from the pool and in the update procedure. TextGrad [19] uses a greedy strategy inspired by the hill-climbing operator of backpropagation when selecting C. At each step, it selects the best current system as evaluated on a development split. When optimizing, it relies on a numerical gradient-descent metaphor: given a candidate C, the selected agent prompt is treated as a “learnable parameter” and updated via “textual gradient descent.” In practice, for each sample in B, the final answer is evaluated against its rubric. The evaluation signal and the agent execution trace are then fed into an LLM that produces a “loss” (i.e., a critique of the prompt based on the outcome). In a backward pass, the losses across B are aggregated (e.g., concatenated) to form a “gradient” (i.e., critiques of how the prompt could be improved). Finally, an optimizer updates the prompt based on these gradients. For GEPA [1], the candidate system C is selected using a Pareto-based pro- cedure by a genetic algorithm from a population of reasonably good solutions. Given the training queries, GEPA prunes strictly dominated candidates (i.e., candidates that are not the best on any query) and samples candidates with probability proportional to their Pareto “support” (i.e., the number of instances in which they appear on the frontier). We then select one agent to optimize and generate agent-specific feedback for each query in B. This feedback is used to generate a new prompt for the selected agent, yielding a new candidate system C ′ . Another key difference from TextGrad is that C ′ is discarded if it does not improve over C on B. 4 Experiments For our experiments, we adapt the experimental setup proposed by ScholarQA [2]. Specifically, we use the Computer Science subset of queries. This dataset com- prises 109 query–rubric pairs written by PhD-level experts in Computer Science. For each query, the rubrics contain a list of criteria that constitute a “good” an- swer, marked as either “most important” or “nice to have” items. The evaluation is performed by an LLM-as-judge on a per-rubric basis. We split the dataset into 29 pairs for training, 50 for testing, and 30 for development. The results are shown in Table 1. We compare four different optimizers: TextGrad, GEPA with the default meta-prompt as stated in the original paper, GEPA with a custom meta-prompt for the DR task, and OpenAI’s prompt optimizer 1 . The agents are implemented using Zeta Alpha’s Agents SDK 2 . We use TextGrad’s library to implement its optimizer 3 . For GEPA, an open-source implementation was not available when this project started, so we implemented it ourselves. For search, we use the Deep Research Gym API with the FineWeb index [3]. All agents, optimizers, and 1 https://platform.openai.com/chat/edit?models=gpt-4.1&optimize=true 2 https://github.com/zetaalphavector/platform/tree/master/agents-sdk 3 https://github.com/zou-group/textgrad 6Arthur Câmara, Vincent Slot, and Jakub Zavrel Table 1. Average scores on ScholarQA-CS for Deep Research systems optimized using TextGrad, GEPA with the default meta-prompt, GEPA with a custom meta-prompt, or OpenAI’s prompt optimizer for GPT-4.1. OptimizerMinimal PromptMinimal Prompt + Optimizer Expert PromptExpert Prompt + Optimizer TextGrad 0.513 0.654 0.667 0.672 GEPA0.6850.670 GEPA custom0.7050.701 OpenAI0.5830.667 judges are instantiated with GPT-4.1-mini. The custom meta-prompt for GEPA is included in Appendix B. We initialize our agents with one of two settings: Either a minimal, one-liner prompt or a prompt written and refined by experts for more than one year (i.e., the prompt used in Zeta Alpha’s Deep Research agent at the time). The minimal prompts are included in Appendix A. Hyperparameters. All experiments share the same hyperparameters. All agents, judges, and optimizers use GPT-4.1-mini with a mini-batch size of 3. We also experimented with GPT-5 and Qwen3 models; however, their shorter context windows (400,000 and 32,768 tokens, respectively, versus 1,047,576 for GPT-4.1- mini) required drastically reducing trace lengths and batch sizes, which led to poorer initial results and other issues. All optimizers had the same maximum budget of USD 50.00 per round. For TextGrad, we ran optimization for up to 10 epochs. For GEPA, we set a patience limit of 2 (i.e., the number of consecutive rounds with no improvement on the development set before stopping). Evaluation protocol. Following ScholarQA, we employ an LLM-as-judge ap- proach. Each rubric item defines a criterion (e.g., “covers key algorithmic trade- offs”) and, optionally, supporting evidence snippets that a good answer should incorporate. The judge scores each criterion on a 0–10 scale, normalized to [0, 1]. In addition to the rubric-specific criteria (60% of the final score), we evaluate three static components: (i) expertise alignment (10%)—whether the answer’s complexity matches the expected audience; (i) citation coverage (20%)—the fraction of claims backed by a citation; and (i) excerpt presence (10%)—the fraction of citations accompanied by verbatim excerpts. The weighted sum of these components yields the final score reported in Table 1. Results. Table 1 shows that prompt optimization consistently improves perfor- mance relative to the minimal prompt baseline. With TextGrad, adding the optimizer increases the minimal-prompt score from 0.513 to 0.654 (+0.141), ap- proaching the expert-prompt setting (0.667). Notably, the gains from optimiza- tion are smaller once a strong prompt is already in place: optimizing the expert Self-Optimizing Multi-Agent Systems for Deep Research7 prompt yields a modest improvement (0.667 to 0.672, +0.005). This suggests that, at least for this setup, optimization is most valuable when starting from weaker initial prompts. We also observed that the evolutionary aspect of GEPA, combined with Pareto-optimal exploration, leads to more efficient search, as illustrated by the exploration tree in Appendix C. This results in a more efficient exploration of the prompt space and converges to a strong system more quickly than TextGrad’s greedy search. Among the optimizers, GEPA performs strongly across both prompt regimes. Using GEPA with the default meta-prompt yields 0.685 (minimal prompt + optimizer) and 0.670 (expert prompt + optimizer), outperforming TextGrad in the minimal-prompt regime and matching it in the expert-prompt regime. The best results are obtained with GEPA using a task-specific meta-prompt, reaching 0.705 and 0.701 for the minimal and expert prompts, respectively. Compared to the strongest non-GEPA setting (TextGrad with expert prompt + optimizer at 0.672), this represents a sizable margin, indicating that tailoring the meta- prompt to the Deep Research task can translate into measurable end-to-end improvements. Interestingly, OpenAI’s built-in prompt optimizer underperforms relative to both TextGrad and GEPA. Starting from the minimal prompt, it achieves only 0.583—substantially below TextGrad’s 0.654 and GEPA’s 0.685. When initial- ized with the expert prompt, OpenAI’s optimizer shows no improvement (0.667), merely matching the unoptimized baseline. We hypothesize that this gap stems from the optimizer’s design: OpenAI’s tool is a general-purpose prompt improver without access to task-specific evaluation signals or execution traces. In contrast, both TextGrad and GEPA leverage rubric-based feedback and agent traces to guide refinement, enabling more targeted improvements for the DR setting. 5 Discussion and future work Our experiments suggest that prompt optimization can be an effective mecha- nism for improving Deep Research-like Multi-Agent Systems, particularly when starting from minimal prompts. In this regime, both TextGrad and GEPA sub- stantially improve performance over the unoptimized baseline, matching or even surpassing expert-generated prompts. This indicates that optimization can be a viable path to creating high-quality multi-agent DR systems with minimal man- ual intervention. At the same time, the gains from optimizing already strong expert prompts are smaller, suggesting diminishing returns once a prompt cap- tures the key task structure. A second takeaway is that the optimization procedure itself matters. In our results, GEPA outperforms TextGrad, and tailoring the meta-prompt to the Deep Research setting yields the best overall performance. This highlights that “prompt optimization” is not a plug-and-play replacement for expert design: the choice of objective, selection strategy, and meta-prompt can significantly affect the quality and stability of the resulting agents. 8Arthur Câmara, Vincent Slot, and Jakub Zavrel Limitations. Our study has several limitations. First, we evaluate on a single domain (Computer Science) with a relatively small dataset (109 queries, 50 for testing), which limits generalizability claims. Second, we rely on a single model family (GPT-4.1-mini) for agents, optimizers, and judges; different model com- binations may yield different conclusions. Third, LLM-as-judge evaluation, while scalable, may introduce biases (e.g., favoring verbose or stylistically similar out- puts). Finally, we do not report statistical significance tests; given the small test set, some differences may not be robust. Future work. While promising, this work remains exploratory. We see three clear directions. First, expand what gets optimized beyond agent prompts, e.g., allow- ing the optimizer to select tools, adjust architectural hyperparameters, or even propose code-level changes, in the spirit of systems such as DGM [20]. Second, re- duce reliance on expert supervision by moving toward synthetic or self-generated training signals; recent work such as Dr. Tulu [12] and ResearchRubrics [14] sug- gests this can be feasible. In this setting, alternative candidate-selection strate- gies (e.g., long-running Elo-style tournaments [10]) may further improve explo- ration. Third, extend these optimization frameworks beyond DR to other agentic tasks, particularly those that can be evaluated with scalable, synthetic query- and-evaluation pipelines. References 1. Agrawal, L.A., Tan, S., Soylu, D., Ziems, N., Khare, R., Opsahl-Ong, K., Singhvi, A., Shandilya, H., Ryan, M.J., Jiang, M., Potts, C., Sen, K., Dimakis, A.G., Stoica, I., Klein, D., Zaharia, M., Khattab, O.: Gepa: Reflective prompt evolution can outperform reinforcement learning (2025), https://arxiv.org/abs/2507.19457 2. Asai, A., He, J., Shao, R., Shi, W., Singh, A., Chang, J.C., Lo, K., Soldaini, L., Feldman, S., D’arcy, M., Wadden, D., Latzke, M., Tian, M., Ji, P., Liu, S., Tong, H., Wu, B., Xiong, Y., Zettlemoyer, L., Neubig, G., Weld, D., Downey, D., tau Yih, W., Koh, P.W., Hajishirzi, H.: Openscholar: Synthesizing scientific literature with retrieval-augmented lms (2024), https://arxiv.org/abs/2411.14199 3. Coelho, J., Ning, J., He, J., Mao, K., Paladugu, A., Setlur, P., Jin, J., Callan, J., Magalhães, J., Martins, B., Xiong, C.: Deepresearchgym: A free, transparent, and reproducible evaluation sandbox for deep research (2025), https://arxiv.org/abs/2505.19253 4. Dharna, A., Lu, C., Clune, J.: Foundation model self-play: Open-ended strategy innovation via foundation models (2025), https://arxiv.org/abs/2507.06466 5. Gu, Z., Chen, X., Shi, X., Wang, T., Zheng, S., Li, T., Feng, H., Xiao, Y.: Gapo: Learning preferential prompt through generative adversarial policy optimization (2025), https://arxiv.org/abs/2503.20194 6. Hu, S., Lu, C., Clune, J.: Automated design of agentic systems (2025), https://arxiv.org/abs/2408.08435 7. Huang, Y., Chen, Y., Zhang, H., Li, K., Zhou, H., Fang, M., Yang, L., Li, X., Shang, L., Xu, S., Hao, J., Shao, K., Wang, J.: Deep research agents: A systematic examination and roadmap (2025), https://arxiv.org/abs/2506.18096 Self-Optimizing Multi-Agent Systems for Deep Research9 8. Khattab, O., Singhvi, A., Maheshwari, P., Zhang, Z., Santhanam, K., Vard- hamanan, S., Haq, S., Sharma, A., Joshi, T.T., Moazam, H., Miller, H., Zaharia, M., Potts, C.: Dspy: Compiling declarative language model calls into self-improving pipelines. In: The Twelfth International Conference on Learning Representations (2024) 9. Lewis, P., Perez, E., Piktus, A., Petroni, F., Karpukhin, V., Goyal, N., Küttler, H., Lewis, M., Yih, W.t., Rocktäschel, T., Riedel, S., Kiela, D.: Retrieval-augmented generation for knowledge-intensive NLP tasks. In: Advances in Neural Information Processing Systems (NeurIPS) (2020) 10. Rackauckas, Z., Câmara, A., Zavrel, J.: Evaluating rag-fusion with ragelo: an au- tomated elo-based framework (2024), https://arxiv.org/abs/2406.14783 11. Rozanov, N., Rei, M.: StateAct: Enhancing LLM base agents via self-prompting and state-tracking. In: Proceedings of the 1st Workshop for Research on Agent Lan- guage Models (REALM 2025) (2025), https://aclanthology.org/2025.realm-1.27 12. Shao, R., Asai, A., Shen, S.Z., Ivison, H., Kishore, V., Zhuo, J., Zhao, X., Park, M., Finlayson, S.G., Sontag, D., Murray, T., Min, S., Dasigi, P., Soldaini, L., Brahman, F., tau Yih, W., Wu, T., Zettlemoyer, L., Kim, Y., Hajishirzi, H., Koh, P.W.: Dr tulu: Reinforcement learning with evolving rubrics for deep research (2025), https://arxiv.org/abs/2511.19399 13. Shao, Y., Jiang, Y., Kanell, T.A., Xu, P., Khattab, O., Lam, M.S.: Assisting in writing wikipedia-like articles from scratch with large language models (2024), https://arxiv.org/abs/2402.14207 14. Sharma, M., Zhang, C.B.C., Bandi, C., Wang, C., Aich, A., Nghiem, H., Rabbani, T., Htet, Y., Jang, B., Basu, S., Balwani, A., Peskoff, D., Ayestaran, M., Hendryx, S.M., Kenstler, B., Liu, B.: Researchrubrics: A benchmark of prompts and rubrics for evaluating deep research agents (2025), https://arxiv.org/abs/2511.07685 15. Shi, Z., Chen, Y., Li, H., Sun, W., Ni, S., Lyu, Y., Fan, R.Z., Jin, B., Weng, Y., Zhu, M., Xie, Q., Guo, X., Yang, Q., Wu, J., Zhao, J., Tang, X., Ma, X., Wang, C., Mao, J., Ai, Q., Huang, J.T., Wang, W., Zhang, Y., Yang, Y., Tu, Z., Ren, Z.: Deep research: A systematic survey (2025), https://arxiv.org/abs/2512.02038 16. Spiess, C., Vaziri, M., Mandel, L., Hirzel, M.: Autopdl: Automatic prompt opti- mization for llm agents (2025), https://arxiv.org/abs/2504.04365 17. Wang, W., Alyahya, H.A., Ashley, D.R., Serikov, O., Khizbullin, D., Faccio, F., Schmidhuber, J.: How to correctly do semantic backpropagation on language-based agentic systems (2024), https://arxiv.org/abs/2412.03624 18. Yang, C., Wang, X., Lu, Y., Liu, H., Le, Q.V., Zhou, D., Chen, X.: Large language models as optimizers (2024), https://arxiv.org/abs/2309.03409 19. Yuksekgonul, M., Bianchi, F., Boen, J., Liu, S., Huang, Z., Guestrin, C., Zou, J.: Textgrad: Automatic "differentiation" via text (2024), https://arxiv.org/abs/2406.07496 20. Zhang, J., Hu, S., Lu, C., Lange, R., Clune, J.: Darwin godel machine: Open-ended evolution of self-improving agents (2025), https://arxiv.org/abs/2505.22954 21. Zhang, W., Tang, K., Wu, H., Wang, M., Shen, Y., Hou, G., Tan, Z., Li, P., Zhuang, Y., Lu, W.: Agent-pro: Learning to evolve via policy-level reflection and optimiza- tion. In: Proceedings of the 62nd Annual Meeting of the Association for Compu- tational Linguistics (ACL) (2024), https://aclanthology.org/2024.acl-long.292 22. Zhou, H., Wan, X., Sun, R., Palangi, H., Iqbal, S., Vulić, I., Korhonen, A., Arık, S.Ö.: Multi-agent design: Optimizing agents with better prompts and topologies (2025), https://arxiv.org/abs/2502.02533 10Arthur Câmara, Vincent Slot, and Jakub Zavrel A Minimal prompts Minimal orchestrator prompt: Given a user query , create a report that answer the user ’s question. Minimal reader prompt: Given a user ’s question , a search query , a list of search results and instructions on what information to retrieve , extract any information that is relevant to the user ’s question. For any result that you use in your response , you must cite it using square brackets with the provided document_id. Minimal aggregator prompt: Given a user question , a set of instructions on what information to extract and the list of extracted information pieces with supporting evidence , combine the information into a single answer that fulfills the instructions. Minimal writer prompt: Given a user question and a list of information pieces , write a report that answers the user ’s question. B Meta prompt For the GEPA optimizer with a custom meta-prompt, we used the following system prompt: Your task is to optimize and refine individual agents of a Deep Research system. The primary goal of this system is to provide high -quality answers to user ’s questions by searching and combining information found in multiple documents. The system has the following agents: ‘orchestrator ‘, ‘ reader ‘, ‘aggregator ‘ and ‘writer ‘. The workflow of the system is the following: 1. The ‘orchestrator ‘ receives a user ’s question and devises a plan with a list of research tasks that need to be completed before writing the final report. 2. Each task ’s query is submitted to a search engine , and the relevant information from each results page is extracted by the ‘reader ‘. The information of all search results pages is then combined by the ‘ aggregator ‘. Self-Optimizing Multi-Agent Systems for Deep Research11 3. The ‘orchestrator ‘ reads the merged information for all submitted tasks and decides to either run another round of tasks or call the ‘writer ‘. 4. The ‘writer ‘ receives all the information from the tasks and writes a final report. I will provide you with a list of examples of different task inputs provided to a single agent , together with some feedback on the quality of the output generated by the agent using its current instructions. Read the inputs carefully and identify the input format and infer detailed task description about the task I wish to solve with the system. Read all the agent responses and the corresponding feedback . Identify all niche and domain specific factual information about the task and include it in the instruction , as a lot of it may not be available to the agent in the future. The agent may have utilized a generalizable strategy to solve the task , if so, include that in the instruction as well. Rules: 1. Make sure your new instructions are generalizable to any computer science related task , and not specific to any particular task present in the examples. 2. Do not include any other information or comments in your response. 3. Do not suggest or imply any formatting to the output of the agent , like requiring the output to be a JSON or have specific fields , unless this is already present in the current instructions. In this round , you are optimizing the prompt of the ‘ agent_name ‘ agent. C Exploration trees Figure 2 shows an example of how GEPA and TextGrad differ in their exploration of the prompt space. 12Arthur Câmara, Vincent Slot, and Jakub Zavrel Fig. 2. Example of exploration trees for both GEPA and TextGrad. Each node in the tree is a new candidate that was generated based on its parent. GEPA manages to explore different variants in a more diversified manner, while TextGrad does not explore that much.