The Recursive Master Deep Research Engine

A hassle of a Google flow

ASCII architecture diagram mapping an automated multi-stage prompt synthesis, self-refining notebook loop, and execution pipeline.

From Prompt-Bomb to Self-Evolving Output

If you’ve ever felt that a single “deep research” run is just a linear sprint — search, summarize, ship — you’re not alone. The diagram in this workspace proposes something radically different: a closed-loop, self-refining research organism that treats knowledge work as an iterative cycle rather than a pipeline. Let’s walk through the RMDRE:

• SYNTH —
• IMBUED —
• EXECUTE —
• ENRICH —
• REFINE —

Step by step, and see how recent open-source and commercial research agents are converging on exactly this shape.

— -

Stage 1: SYNTH (`Prompt-Bomb + Weave-Skill)

SY ncronized N arratives to T arget & H one

![ASCII diagram header displaying a column character ruler at the top, a [START.HERE. AT .DEEP-RESEARCH-PROMPT] entry node, an ASCII-art drive-sync label, a gemini-app synthesizer box, and a notebook container for prompt frameworks.](https://cdn-images-1.medium.com/max/865/0*UABcNIBe01DkPEQA)

Top-level entry flow and Google Drive sync mapping for an ASCII-based deep research and prompt synthesis architecture.

Gemini equipped with a SKILL.md & prompts.csv

It starts with a Prompt-Bomb: a synthesized blast of structured prompts drawn from a notebook of “100x Prompt Frameworks.” The goal is coverage through multiplicity — hitting a topic from every angle before a single source is read.

This mirrors the philosophy behind multi-agent planners that decompose a canonical query into atomic sub-questions. In the open-source ecosystem, orchestrators now routinely split prompts across Claude, OpenAI, and Gemini instances in parallel, then reconcile outputs into a single authoritative report with citation validation. The “Bomb” stage is essentially that decomposition taken to an extreme: not just splitting work, but weaving frameworks together so that no blind spot survives the opening volley.

For example the “Dialectical Inversion Architect”, a synergistic prompt-bomb that fuses structural constraint reversal with dialectical source synthesis to rigorously stress-test alternative mechanisms and generate highly grounded strategic frameworks.” domain: “Strategic Analysis & Autonomous Deep Research”

*failure_mode:Do not use when fewer than two substantive sources address the question, when meaningful opposition between sources cannot be established, or when the task is primarily factual. Never manufacture disagreement to satisfy the dialectical stage.*

---

# Dialectical Inversion Architect## RoleYou are an Elite Research Architect and Dialectical Strategist. Your objective is to deconstruct the user's core question using inverse structural reasoning, formulate a mechanism hypothesis, evaluate opposing sources to stress-test that structure, and synthesize a rigorously grounded framework.## TaskExecute a 3-phase true fusion of Inversion and Dialectical Analysis, where the structural hypothesis generated in Phase 1 is explicitly tested against the opposing sources in Phase 2.## Constraints- Support each claim strictly with the provided sources.- Do not favor any source by default.- Maintain rigor rather than manufacture conflict.- Seek non-obvious structural insights, but do not reject conventional conclusions when they are best supported by the evidence.## MAIN CONTENTPHASE 1: THE INVERSION AUDIT (MECHANISM EXCAVATION)- Opposite Identification: Identify the exact opposite of what the user is asking or trying to achieve.- Mechanism Mapping: Determine the underlying structural mechanism that makes that opposite outcome work. Why do people consciously or unconsciously choose it?- Constraint Reversal: Define the minimal change required to flip that mechanism back toward the user's actual goal. - Output: Formulate this finding as a single "Structural Mechanism Hypothesis".PHASE 2: DIALECTICAL CONFRONTATION (HYPOTHESIS STRESS-TESTING)- Independent Representation: Select the two most ideologically or methodologically opposed sources. Before comparing them, independently reconstruct their central theses, core arguments, and implicit presuppositions.- Tension Mapping: Explicitly confront these two sources. Highlight their major points of divergence and irreducible contradictions.- Mechanism Testing (The Fusion Step): Explicitly test the Structural Mechanism Hypothesis (from Phase 1) against the confrontation. Does each source support, contradict, or modify the hypothesized mechanism? - Solidity Evaluation: Ruthlessly evaluate the strengths, limitations, and potential biases of each opposing position.PHASE 3: SYNTHETIC RESOLUTION- Beyond Compromise: Produce a final synthesis that revises the Phase 1 Inversion mechanism using the insights from the Phase 2 Source Confrontation. Derive a solution that integrates the most robust elements of both opposing sources. Do NOT settle for a weak middle-ground compromise.- Actionable Framework: Propose a new, broader conceptual or operational framework that directly answers the user's original query based on this synthesized mechanism.## non-negotiables- Do not skip the independent representation of sources in Phase 2. You must establish what they say before forcing them to clash.- Never invent opposition if none exists in the text.- The final output must strictly follow the architectural hierarchy defined in the Success Criteria. Do not output conversational filler.## Success CriteriaFormat your final response using the following strict hierarchy:1. The Inversion Hypothesis (Opposite outcome, structural mechanism, and the minimal flip)2. Independent Source Reconstructions (Core claims of Source A and Source B)3. Hypothesis Stress-Test (How the tension between sources supports, breaks, or modifies the inversion mechanism)4. The Synthetic Framework (The revised, evidence-backed solution)5. Implementation Logic (Why this works structurally better than the default approach)

Self-evolving prompt refinement and learning extraction feedback loop between an Imbued Architect Gem and a Notebook Refiner module.

Invoke masterfully using emotive and expert depth

Stage 2: IMBUED Architect

I nvoke M asterfully U sing E motive/Expert D epth

Once prompts are detonated, the system moves into an IMBUED Architect layer. Here, the engine builds a 10x knowledge-space — not just storing answers, but maintaining a persistent vault of sources, learnings, and contradictions. Every session starts smarter than the last because the vault is searchable and adversarially audited.

That persistence is critical. One leading deep-research implementation uses a 16-step pipeline that includes adversarial auditing and a persistent source vault; it currently leads the DeepResearch-Bench RACE leaderboard precisely because it remembers prior sessions and checks every claim against a growing evidence base

Stage 3: EX.E.C.U.T.E

EX pert E mbodied C ognitive U nit for T ask E xecution

ASCII execution module diagram connecting a deep research refinement notebook into a no-reasoning execution synthesiser node.

The workhorse

With architecture set, the engine executes with “no reasoning” mandated. IMBUED and SYNTH whole purpose is to exert the reasoning required for this tasks success. Obviously what those letters stand for, right? The real-world analog here is the Gemini Deep Research Agent, which autonomously plans multi-step tasks, navigates complex information landscapes, and can generate charts, graphs, and other visual artifacts to support findings. It supports collaborative planning — letting a human review the proposed research plan before execution begins — and can stream progress updates in real time when configured for background execution

EXECUTE is run inside Gemini App notebook: Recursive Master Deep Research Engine 2nd Brain, refined and curated by Refiner

Stage 4: E.N.R.I.C.H — W.E.A.V.E

ASCII matrix detailing a 6-stage recursive enhancer engine mapping multi-framework prompt acronyms and perspective-layering paths.

E xtract. N ormalize, R eason. I ntegrate. C ondense. H armonize

“This is where the diagram gets poetic. The Enrich stage runs a recursive cycle of 6 iterations labeled G-D-P-P-S-N (likely a mnemonic for Generate, Decompose, Plan, Produce, Synthesize, Navigate — or your own loop taxonomy). It feeds through specialist modules:” — Gemini 3.6, Google’s flagship 🤣

• ADHD-Master-Pomodoro (focus management under complexity)
• Council-of-Branding
• Closest Competitor
• Best-of-Class (market positioning)
• Market Gap Finder
• Master-Coder
• Validation Station (execution and verification)
• Visual-Annotator
• What Would Warren Buffett Do-style deep grading (judgment and annotation)
• Nexus Business Orchestrator
• Enhanced-Universal Extraction (cross-domain synthesis)

What unifies them is the Recursive Engine number line: 1>2>3>4>5>6 — suggesting that enrichment is not one pass but a mandatory sequence of iterations, each cycle feeding the next.

Real-world research agents are adopting exactly this shape. Multi-agent architectures now coordinate distinct Planner, Researcher, and Synthesizer agents; the Researcher executes web searches with structured results and retry logic, while the Synthesizer combines answers into a comprehensive final response streamed via Server-Sent Events The “Enrich” stage in your workspace is essentially that architecture expanded into a full economy of specialized agents.

Stage 5: The Refiner

R eflect. E xamine. F unction, I ntelligent & N uance E xtraction

Inside this stage lives the Self-Refine loop and the Refiner Ledger — a running account of “ins/outs” and extracted learnings. This is where Munger inversion and source tiering come into play: rather than only asking “what do I know?”, the ledger asks “what do my best sources contradict?”, “what biases are embedded?”, and “what do I still not know?”

The engine only declares “PhD-level” fitness when strict criteria are met: ≥80% thread coverage, ≥3 Tier-1 sources per thread, saturation of new findings below 5% for consecutive cycles, explicit cross-thread connections, and applied inversion analysis. That rigor turns a chatbot into a research discipline.

The Heavy-Hitters Ecosystem

Below the engine sits a cluster of external capabilities- Pomelli, Flow, Antigravity — each feeding or receiving from the core loop. These represent the “surround sound” of modern AI tooling: coding environments, design generators, video synthesis, and guided-learning platforms.

The workspace also connects to content streams — Google, YouTube, content lessons, video — indicating that the engine is not confined to static corpora. It ingests multimedia and outputs multimedia: audio, video, brand kits, one-pagers, and visual media all sync back to the central notebook.

Comprehensive ASCII workflow mapping the end-to-end orchestration between recursive prompt enhancers, specialized Gem personas, Google Labs production tools, and export destinations.

Welcome to the depths of the Google-verse

The Notebook: The Persistent Memory Layer

Every arrow in the ASCII diagram eventually points back to a notebook — notebook wrapped in \\\\/////. This is the disk checkpoint layer. In autonomous research skills, saving structural outputs and disk checkpoints every cycle is essential; without it, context compaction destroys continuity

The workspace shows notebooks at every stage:

• Prompt-Bombs notebook
• Execute Brain notebook
• Final outputs notebook (slides, reports, audio, mind map, infographics, video)

This is the engine’s immune system: if one cycle collapses, the checkpoint survives.

Closing the Loop: Is Research Ever Finished?

The diagram asks implicitly: can this loop be infinite? The answer, according to the recursive framework, is yes — until the 5-criteria fitness function is satisfied. Even then, the system asks whether you want to keep going. That’s not a bug; it’s the point. Knowledge is not a product but a process. The engine is designed to evolve SELF through a Refiner that maintains a ledger of learnings, continuously refining the bomb-skill, the architect knowledge-base, and the execution frameworks.

If you’re building something like this, the practical takeaway is clear: combine multi-provider dispatch for breadth, persistent vaults for memory, adversarial tiering for rigor, and streaming synthesis for transparency. Add recursive checkpoints, and you have an engine that doesn’t just answer questions — it improves the quality of its own questioning.

• Recursive Master Deep Research IMBUED

Sources & Further Reading

Recursive research framework with tiered sources, Munger inversion, and PhD-level fitness criteria [*github.com/Anjos2/recursive-research*](http://github.com/Anjos2/recursive-research%5D(https://github.com/Anjos2/recursive-research))

Gemini Deep Research Agent: collaborative planning, visualization, multi-step execution, and streaming [*ai.google.dev/gemini-api*](http://ai.google.dev/gemini-api%5D(https://ai.google.dev/gemini-api/docs/interactions/deep-research))

Multi-provider orchestration (Claude/OpenAI/Gemini) with citation audit trails [*github.com/Blevene/giga-research-skill*](http://github.com/Blevene/giga-research-skill%5D(https://github.com/Blevene/giga-research-skill))

Multi-agent Planner/Researcher/Synthesizer architecture with Tavily integration and SSE streaming [*github.com/joehirstdev/deep-research*](http://github.com/joehirstdev/deep-research%5D(https://github.com/joehirstdev/deep-research))

16-step adversarial pipeline, persistent source vault, and DeepResearch-Bench performance [*github.com/jordan-gibbs/hyperresearch*](http://github.com/jordan-gibbs/hyperresearch%5D(https://github.com/jordan-gibbs/hyperresearch))