# Agentic Research Workflows

URL: https://research-memex.org/docs/craft/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]

A single-turn chat works well for a bounded task: you write a prompt, read the reply, and carry the context to the next turn yourself. Across a multi-stage research project, that arrangement breaks down. Early reasoning disappears into chat scrollback, one model's framing goes unchallenged, and fluent synthesis outruns your reading of the primary material.

Agentic workflows separate those responsibilities. Instead of asking one assistant to hold the whole study, you coordinate specialized roles and models around a shared project record. Each agent handles a bounded job - analysis, critical challenge, synthesis, or memory - while you set the criteria and make the interpretive calls.

If you want to locate your own practice before looking at concrete tools, [Composing an Agentic Research System](/docs/craft/composing-agentic-research-systems) sets out seven distinctions and five functional questions that apply to any method.

```text title="diagram:agentic-workflow"
        TRADITIONAL

+------------+     +-----------------+
| Researcher | <-> | Single AI model |
+------------+     +-----------------+

          AGENTIC

+------------+     +---------------------+
| Researcher | --> | Orchestration layer |
+------------+     +----------+----------+
                              |
             +---------+------+------+
             |         |      |      |
             v         v      v      v
         analysis  challenge  synthesis  memory
```

<span id="the-agentic-research-stack" />
<span id="kimi-plugin-for-claude-code" />

## How the stack works together [#how-the-stack-works-together]

The components in the [Toolkit](/docs/toolkit) are modular instruments rather than a single bundle to install in full. In a qualitative or theory-building project, four tools often divide the work shown above:

- [Interpretive Orchestration](/docs/toolkit/interpretive-orchestration-plugin) paces qualitative analysis through explicit gates (`@stage1-listener`, `@dialogical-coder`, `@research-configurator`, `@scholarly-companion`) so your own reading comes before model synthesis.
- [Vox MCP](/docs/toolkit/vox-mcp) queries multiple providers from inside your workspace without a wrapper system prompt, keeping side-by-side model comparisons and open-weight or multilingual checks in one record.
- The [Kimi Plugin](/docs/toolkit/kimi-plugin-cc) brings Kimi into Claude Code or Codex to frame an initial approach, challenge an emerging argument, or review a change against a write allowlist.
- The [Memex Plugin](/docs/toolkit/memex-plugin) records collaborative sessions as dated memos in an Obsidian vault, preserving why a framework moved and what tensions remained unresolved when a session closed.

See [Qualitative Coding and Interpretive Research with AI](/docs/craft/qualitative-research-with-ai) for the methodological protections behind the three phases below, and the [AI Model Reference Guide](/docs/craft/ai-model-reference-guide) for current model choices.

### Phase 1: foundation building [#phase-1-foundation-building]

You code an initial set of documents by hand while [Interpretive Orchestration](/docs/toolkit/interpretive-orchestration-plugin) holds back model coding. [Memex](/docs/toolkit/memex-plugin) records your early analytical memos and theoretical sensitivity, and [Vox MCP](/docs/toolkit/vox-mcp) lets you consult multiple models on research design and methodological trade-offs before you lock the protocol.

### Phase 2: collaborative analysis [#phase-2-collaborative-analysis]

Once your own baseline exists, `@dialogical-coder` runs parallel human and model coding with visible reasoning. When a passage resists a single reading, you can compare independent interpretations through Vox or invite critical challenge from Kimi via the [Kimi Plugin](/docs/toolkit/kimi-plugin-cc). A long-context or open-weight model handles broad corpus and multilingual checks while Memex tracks how categories and anomalies shift across sessions.

### Phase 3: synthesis and writing [#phase-3-synthesis-and-writing]

During synthesis, Memex recall skills and `memex ask` surface patterns and earlier decisions across your session history. Interpretive Orchestration's `@scholarly-companion` tests whether the emerging account fits your methodological tradition, and a reasoning model helps probe rival explanations before you commit to the final argument.

## Current practice: a shared project across hosts [#current-practice-a-shared-project-across-hosts]

Our day-to-day workflow is repository-centered. Kimi is a regular collaborator alongside the models we work with through Codex and Claude Code across reasoning, writing, coding, and sustained project work. What matters most is the difference in perspective: Kimi often notices a different tension or takes another approach.

The host is the interface; the model is a participant in the work. Working with Kimi through Codex or a plugin still brings Kimi's perspective into the project, and native Kimi Code offers a direct workspace route. Each task can draw on a different combination of hosts over the same project files:

```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 our default. Depending on the stage of a study, you can design the workflow yourself, revise an agent's proposal, or delegate workflow construction to a lead agent. When a routine grows elaborate, the [Arrangement Auditor](/docs/craft/roles/arrangement-auditor) role helps test whether each part is earning its keep.

For multi-model tasks where agents need to inspect files and carry out bounded work, we now use [cc-fleet](https://github.com/ethanhq/cc-fleet) more often. [Vox MCP](/docs/toolkit/vox-mcp) remains useful for one-shot consultations and defined prompt workflows, and [DeepThonk](/docs/toolkit/deepthonk) provides an open-source reasoning workbench when a hard question benefits from candidate generation and ranking. Both the [Codex Plugin for Claude Code](https://github.com/openai/codex-plugin-cc) and the [Kimi Plugin](/docs/toolkit/kimi-plugin-cc) stay in the working setup, and we reach for [Lotus Wisdom](/docs/toolkit/lotus-wisdom-mcp) more often than [Sequential Thinking](/docs/toolkit/sequential-thinking-mcp) when a problem needs a deliberate pause.

The [project-opening invitation](/docs/craft/cognitive-blueprint-prompts#a-project-opening-invitation) pairs with this arrangement: invite agents to question your framing and surface possibilities beyond it, then decide together whether to follow them.

Durable research state is distributed across four places rather than trapped in 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](/docs/implementation/foundational-setup/zotero-setup-guide) holds sources and bibliographic records. [Obsidian](/docs/implementation/foundational-setup/obsidian-setup-guide) provides a reading and linking interface over local Markdown files. [Memex](/docs/toolkit/memex-plugin) preserves cross-session reasoning and evolving interpretation. The project repository carries the plans, code, and reports that agents read and update together.

### Let Kimi frame the problem [#let-kimi-frame-the-problem]

One reliable pattern is to begin a methods or implementation task with Kimi. Share the research question, source material, constraints, and evaluation criteria, then ask Kimi to propose an approach and name the assumptions worth questioning.

Next, invite Claude or a GPT model to develop an independent account from the same brief before reading Kimi's proposal. Bring the two accounts together and examine what each noticed, missed, or made possible. You can then choose one direction, combine them, or ask Kimi to carry the next stage forward as well as critique it.

The roles can reverse on the next task. Different perspectives are a reason to work across models; agreement alone does not establish that an account is sound.

## Connecting the rest of the toolkit [#connecting-the-rest-of-the-toolkit]

This workflow connects directly to the runtime and tool guides across the rest of the book:

- Workspace agent hosts such as [Codex](/docs/implementation/agentic-ai-tools/codex-setup-guide), [Claude Code](/docs/implementation/agentic-ai-tools/claude-code-setup-guide), Kimi Code, [Antigravity CLI](/docs/implementation/agentic-ai-tools/antigravity-cli-setup-guide), and [OpenCode](/docs/implementation/agentic-ai-tools/opencode-setup-guide) coordinate through the same project folder. See [Agent Runtimes: How Workspace Agents Work](/docs/implementation/ai-environment-setup/cli-setup-guide), including [ways to work with Kimi](/docs/implementation/ai-environment-setup/cli-setup-guide#working-with-kimi).
- The [Toolkit](/docs/toolkit) catalogs the plugins, skills, MCP servers, and platforms that plug into those hosts, including [MinerU](/docs/toolkit/mineru-mcp) for layout-aware PDF parsing, [OpenAlex](/docs/implementation/foundational-setup/openalex-setup-guide) and [Research Scanner](/docs/toolkit/research-scanner) for literature discovery, and [OpenInterviewer](/docs/toolkit/openinterviewer) for participant-facing qualitative studies.

## Getting started with agentic research [#getting-started-with-agentic-research]

You do not need the full stack to benefit from agentic workflows. Start with one model, one workspace, and one bounded task in a readable project folder, then add a component only when you hit a specific bottleneck:

- set up the desk: if you are starting on a fresh machine, [Carrel](/docs/toolkit/carrel) interviews you and configures the Obsidian-centered environment in one conversational pass, or you can build it step by step with the [Quick Start Checklist](/docs/implementation/foundational-setup/quick-start-checklist)
- invite a second perspective: add the [Kimi Plugin](/docs/toolkit/kimi-plugin-cc) or [Vox MCP](/docs/toolkit/vox-mcp) when a research design, draft, or coding decision needs an independent framing or critique
- preserve decisions across sessions: add the [Memex Plugin](/docs/toolkit/memex-plugin) when your project spans weeks and you need searchable memos of why your analytical choices moved
- enforce qualitative gates: adopt [Interpretive Orchestration](/docs/toolkit/interpretive-orchestration-plugin) when you want staged checkpoints for solo grounding, dialogical coding, and methodological tradition checks
- coordinate across hosts: keep sources in Zotero and plans, notes, and reports in a shared repository so Codex, Claude Code, and Kimi Code can hand work off through inspectable files rather than chat transcripts