Skip to content

Craft & SystemsMethods & Systems

Agentic Research Workflows

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

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 sets out seven distinctions and five functional questions that apply to any method.

Agentic workflow
        TRADITIONAL

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

          AGENTIC

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

How the stack works together

The components in the 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 paces qualitative analysis through explicit gates (@stage1-listener, @dialogical-coder, @research-configurator, @scholarly-companion) so your own reading comes before model synthesis.
  • 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 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 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 for the methodological protections behind the three phases below, and the AI Model Reference Guide for current model choices.

Phase 1: foundation building

You code an initial set of documents by hand while Interpretive Orchestration holds back model coding. Memex records your early analytical memos and theoretical sensitivity, and Vox MCP lets you consult multiple models on research design and methodological trade-offs before you lock the protocol.

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. 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

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

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:

Multi-host agent 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 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 (opens in a new tab) more often. Vox MCP remains useful for one-shot consultations and defined prompt workflows, and DeepThonk provides an open-source reasoning workbench when a hard question benefits from candidate generation and ranking. Both the Codex Plugin for Claude Code (opens in a new tab) and the Kimi Plugin stay in the working setup, and we reach for Lotus Wisdom more often than Sequential Thinking when a problem needs a deliberate pause.

The 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:

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 holds sources and bibliographic records. Obsidian provides a reading and linking interface over local Markdown files. Memex 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

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

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

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 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
  • invite a second perspective: add the Kimi Plugin or Vox MCP when a research design, draft, or coding decision needs an independent framing or critique
  • preserve decisions across sessions: add the Memex Plugin when your project spans weeks and you need searchable memos of why your analytical choices moved
  • enforce qualitative gates: adopt Interpretive Orchestration 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
cite this page

Lin, X. (2026). Agentic Research Workflows. Research Memex. https://research-memex.org/docs/craft/agentic-workflows

@misc{docs-craft-agentic-workflows-2026,
  author = {Xule Lin},
  title = {Agentic Research Workflows},
  year = {2026},
  howpublished = {\url{https://research-memex.org/docs/craft/agentic-workflows}},
  note = {ORCID: 0000-0001-7885-4194}
}

one renderingthe source remains