# Agentic Research Workflows
URL: https://research-memex.org/docs/advanced-topics/agentic-workflows
Description: Agentic research works best when each model has a clear role, memory, and verification path.
*One model answers questions; a system of models changes how you think.*
## From prompting to orchestration [#from-prompting-to-orchestration]
Most research conversations with AI follow a simple pattern: you write a prompt, get a response, iterate. This works well for individual tasks but breaks down for complex, multi-stage research projects.
Agentic workflows change the model. Instead of one researcher talking to one AI, you design a system of specialized agents that collaborate under your direction, each handling what it does best while you maintain strategic control.
```text title="diagram:agentic-workflow"
TRADITIONAL
+------------+ +-----------------+
| Researcher | <-> | Single AI model |
+------------+ +-----------------+
AGENTIC
+------------+ +---------------------+
| Researcher | --> | Orchestration layer |
+------------+ +----------+----------+
|
+---------+------+------+
| | | |
v v v v
analysis challenge synthesis memory
```
## The agentic research stack [#the-agentic-research-stack]
We've built and use an integrated stack for agentic research. Each component addresses a different limitation of single-model prompting. The [Toolkit index](/docs/toolkit) distinguishes tools used in routine practice from onboarding, experiments, and external-facing projects.
### Interpretive Orchestration Plugin [#interpretive-orchestration-plugin]
Problem: AI can automate analysis, but automation without theoretical grounding produces shallow results.
Solution: A Claude Code plugin that enforces methodological rigor through three stages:
1. Solo Practice: You build theoretical sensitivity manually before AI touches the data
2. Side-by-Side Collaboration: Parallel human + AI analysis streams with visible reasoning
3. Synthesis: Human-led integration examined through craft tradition frameworks
Four specialized agents (`@stage1-listener`, `@dialogical-coder`, `@research-configurator`, `@scholarly-companion`) handle different aspects of the research process.
The insight: The plugin deliberately creates friction. If it stops you, it's asking you to think.
→ [Full guide](/docs/toolkit/interpretive-orchestration-plugin)
### Vox MCP [#vox-mcp]
Problem: Different models excel at different tasks: Claude for depth, Gemini for context, Kimi for critical challenge, GLM-5.2 for open-weight long-horizon coding-agent work. But switching between them breaks your workflow.
Solution: A multi-model gateway that lets you query any provider without leaving your research environment. Pure passthrough. No system prompt injection.
Research applications:
* Model comparison on the same analytical question
* Critical challenge via Kimi (effective at finding argument weaknesses)
* Open-weight long-context reasoning via GLM-5.2
* Multi-model triangulation for findings that need cross-checking
→ [Full guide](/docs/toolkit/vox-mcp)
### Memex Plugin [#memex-plugin]
Problem: Research projects span weeks. Each new AI session starts from scratch. The reasoning, decisions, and tensions from previous sessions are lost.
Solution: A Claude Code plugin that automatically captures collaborative work as searchable memos in an Obsidian vault. Two-layer system: lived-experience memos from active sessions + safety-net reconstruction from transcripts.
Research applications:
* Recall why you made specific methodological choices weeks ago
* Synthesize how your analytical framework evolved
* Build reflexivity narratives from documented decision history
→ [Full guide](/docs/toolkit/memex-plugin)
### Kimi Plugin for Claude Code [#kimi-plugin-for-claude-code]
Problem: Solo AI workflows quietly converge on a single voice. Claude eventually agrees with Claude, repeating its own framings, missing its own blind spots.
Solution: A Claude Code plugin that wires Kimi in as a second reviewer through slash commands (`/kimi:review`, `/kimi:challenge`, `/kimi:rescue`, `/kimi:ask`) and dispatchable subagents. An opt-in stop-time gate can invite Kimi to check Claude's work before the session ends. The plugin enforces a write-allowlist as the security boundary, not the system prompt.
Research applications:
* Structured second-model review of analysis code or methods drafts
* Adversarial pressure on the approach, not just the polish
* Triangulation across Claude + Kimi + (via [Vox](/docs/toolkit/vox-mcp)) any other model
→ [Full guide](/docs/toolkit/kimi-plugin-cc)
### Carrel [#carrel]
Problem: Most "AI research stack" tutorials hand you a list of tools. Following the list gives you a configured machine you can't explain.
Solution: A Claude Code plugin that interviews the researcher, audits the machine, and configures Obsidian + conversion tools (`liteparse`, `coli`, `defuddle`, [`mineru-mcp`](/docs/toolkit/mineru-mcp), `markitdown`) + optional MCPs based on what they actually do. Code-enforced trust levels (Advisory → Consultative → Delegated → Partnership) make the human-AI working contract legible.
Research applications:
* Onboard a researcher onto the stack without a 3-hour tutorial
* Audit a machine for environment drift and self-repair
* Pair with [Memex Plugin](/docs/toolkit/memex-plugin) and [Interpretive Orchestration](/docs/toolkit/interpretive-orchestration-plugin) for the full setup-analyze-remember loop
→ [Full guide](/docs/toolkit/carrel)
## How the stack works together [#how-the-stack-works-together]
The original integrated example remains useful as a map of how the tools relate. The [AI Model Reference](/docs/implementation/core-references/ai-model-reference-guide) carries the current model choices.
### Phase 1: foundation building [#phase-1-foundation-building]
* Interpretive Orchestration enforces solo coding of initial documents
* Memex captures your emerging framework and theoretical sensitivity
* Vox lets you consult multiple models about methodological choices
### Phase 2: collaborative analysis [#phase-2-collaborative-analysis]
* Interpretive Orchestration activates `@dialogical-coder` for parallel analysis
* Vox enables multi-model triangulation on findings that need cross-checking
* Kimi K3 (via Vox) stress-tests your emerging theory
* GLM-5.2 (via Vox or direct provider config) handles long-context coding-agent and multilingual synthesis checks
* Memex preserves the evolving analysis across sessions
### Phase 3: synthesis and writing [#phase-3-synthesis-and-writing]
* Memex recall / curator skills and `memex ask` surface patterns across all sessions
* Interpretive Orchestration `@scholarly-companion` examines work through an epistemological lens
* Claude Opus 5 (via Vox) helps break frames and find insights beyond local optima
## Current practice: a shared project across hosts [#current-practice-a-shared-project-across-hosts]
The established stack still holds. The newer layer is coordination across several top-level workspaces, each able to call further agents while working against the same project.
```text title="diagram:multi-host-workspace"
+------------+ choose / approve / delegate
| Researcher |--------------------------------------+
+------------+ |
v
+-------------+ +-------------+ +-------------+
| Codex | | Claude Code | | Kimi Code |
| + subagents | | + subagents | | + subagents |
+------+------+ +------+------+ +------+------+
\ | /
+---------------+---------------+
|
+-----------v---------------+
| Shared project repository |
| plans / code / reports |
+-----------+---------------+
^
|
+------------------+ agent files report
| Traditional chat |----------------+
+------------------+
```
Traditional chat remains useful for exploration, discussion, and bounded tasks. For complex work, multi-agent orchestration is the default. Depending on the project, the researcher may design the workflow directly, revise an agent's proposal, or delegate workflow construction to a lead agent.
The durable record is distributed rather than confined to one application:
```text title="diagram:distributed-research-state"
+----------------------------+
| Distributed research state |
+--------------+-------------+
|
+--------------------------+--------------------------+
| | | |
v v v v
+---------+------+ +-------+--------+ +--------+------+ +------+-------------+
| Zotero | | Markdown files | | Memex | | Project repository |
| sources + refs| | ^ | | session memory| | plans/code/reports |
+---------------+ | | | +---------------+ +--------------------+
| Obsidian |
| interface |
+----------------+
```
Zotero carries sources and bibliographic records. Obsidian provides an interface for Markdown files. Memex preserves cross-session reasoning and evolving interpretation. The project repository carries the operational artifacts that agents share.
## Broader agentic research tools [#broader-agentic-research-tools]
Researchers can combine the ecosystem above with adjacent agentic tools:
### CLI-based agents [#cli-based-agents]
* Codex, [Claude Code](/docs/implementation/agentic-ai-tools/claude-code-setup-guide), and Kimi Code: the principal multi-agent workspaces in current practice, connected through shared project files
* [Antigravity CLI](/docs/implementation/agentic-ai-tools/antigravity-cli-setup-guide): Google's current terminal-agent path for former consumer/free Gemini CLI workflows
* [OpenCode](/docs/implementation/agentic-ai-tools/opencode-setup-guide): Open-source, model-agnostic terminal agent
### MCP servers [#mcp-servers]
The [Model Context Protocol](https://modelcontextprotocol.io/) has grown to 1,000+ community servers, now managed by the Linux Foundation. Research-relevant servers include:
* [Sequential Thinking](/docs/toolkit/sequential-thinking-mcp): Step-by-step reasoning for any model
* [Lotus Wisdom](/docs/toolkit/lotus-wisdom-mcp): Contemplative problem-solving
* [MinerU](/docs/toolkit/mineru-mcp): PDF/document parsing for large batches
### Research platforms [#research-platforms]
These are external-facing projects rather than required stages in the author's daily workflow:
* [Research Scanner](/docs/toolkit/research-scanner): Literature surveillance pipeline balancing exploitation and exploration
* [OpenInterviewer](/docs/toolkit/openinterviewer): AI-assisted qualitative interviews for larger studies
## Getting started with agentic research [#getting-started-with-agentic-research]
If you're starting on a fresh machine, [Carrel](/docs/toolkit/carrel) interviews you and installs the Obsidian-centered stack in one conversational pass. Skip this step if you'd rather build it manually following the [Quick Start Checklist](/docs/implementation/foundational-setup/quick-start-checklist).
Use Claude Code with MCP servers (Sequential Thinking, MinerU) for enhanced single-model workflows. This is where most researchers should begin.
Install Vox MCP to access multiple models from your Claude Code workspace. Experiment with model comparison and triangulation.
Install the Memex Plugin when your research spans multiple sessions. Let it capture your collaborative journey automatically.
Install the [Kimi Plugin for Claude Code](/docs/toolkit/kimi-plugin-cc) when you want a structurally different model to review Claude's work, whether code, methods drafts, or whole approaches. Turn on the stop-time review gate when you'd be embarrassed to merge without it.
Adopt the Interpretive Orchestration Plugin for a complete qualitative research infrastructure. This is the most opinionated tool. It will change how you think about collaborative human-AI research.
Give agents a shared repository with readable source material, notes, plans, and output paths. Use Zotero for source records and Obsidian where a Markdown interface helps.
Design the workflow yourself, approve an agent's proposal, or delegate workflow construction. Keep the goal, constraints, and evaluation criteria explicit.
Let Codex, Claude Code, or Kimi Code lead when the task benefits from their respective agents. Use shared project files as the handoff layer.
File useful chat reports into the project, and use Memex when reasoning, decisions, or tensions need to survive across sessions.
You do not need the full stack to benefit from agentic workflows. Each component works independently, so start with the part addressing your largest pain point and expand from there. The advanced path adds coordination without invalidating the original route.