Session 4: Advanced Agentic Workflows

Agentic design is the architecture of thinking at scale.

We now turn to designing agentic systems (Systems where AI agents can act autonomously within defined boundaries and quality controls) for complex, multi-step research processes. This is about architectural thinking: how to give each agent a role, define quality gates, and keep the human researcher in control.

This session also develops the critical thinking to decide when such systems are appropriate, how to maintain quality control, and where human judgment remains irreplaceable. By the end of this guide, you'll move from one-off prompting to deliberate orchestration.

For the short vault exercise, bring your completed Session 3 note and evidence table instead of a full Session 1 benchmark. Start with one observed problem or unresolved question. Copy Session 4 into notes and choose a tool run, human rehearsal, or design only. The worksheet explains each route; no agent framework is required for a manual handoff.

Learning outcomes

By the end of this session, you'll be able to:

• Design multi-agent workflows where different AI roles collaborate on complex research tasks
• Implement quality control frameworks that maintain research rigor in automated systems
• Critically evaluate when agentic approaches add value and when simpler methods work better
• Navigate the ethical and professional considerations of increasingly autonomous research systems
• Build practical, cost-effective workflows that integrate into your academic research practice
• Compose individually designed agents into one team, run it, and read its first failure together

Multi-agent research architecture

           +----------------------+
           | Human architect      |
           | goal / roles / gates |
           +----------+-----------+
                      |
                delegates through
                  checkpoints
                      |
                      v
           specialized AI roles
                      |
+-----------+  +----------+  +-----------+  +----------+
| discovery |  | analysis |  | synthesis |  | critique |
+-----+-----+  +----+-----+  +-----+-----+  +----+-----+
      |             |              |             |
  relevance       logic         novelty      integration
      |             |              |             |
      +-------------+------+-------+-------------+
                             |
                       all gates pass
                             |
                             v
                  +----------+----------+
                  | validated synthesis |
                  +----------+----------+
                             |
                     feedback / refine
                             |
                             +--------> Human architect

Key concepts: the workshop prep kit

The readings below trace the arc from vision to practice: a high-level case for AI co-scientists, the engineering realities of multi-agent systems, practical implementation patterns, and how agentic workflows may reshape academic research.

• Conceptual architecture ("Towards an AI co-scientist (opens in a new tab)"): the high-level vision, moving from single prompts to orchestrating a team of specialized AI roles.
• Engineering reality ("How we built our multi-agent research system (opens in a new tab)"): the "what can go wrong" guide. Learning from professional teams helps anticipate and solve common problems.
• Practical implementation ("Claude Code: Best practices (opens in a new tab)"): the primary lab manual, with specific instructions and code patterns for hands-on work.
• Professional context ("From Scarcity to Abundance (opens in a new tab)"): how agentic workflows may change academic research practice.

Building your research architecture: a step-by-step guide

One prompt, a team

In the module's second run, tutored by Raj Arasanal, one prompt that described the review's phases was enough for a Cherry Studio agent to create a sub-agent for each phase and run them. Cherry Studio's documentation lists Task and Workflow among an agent's built-in tools, for handling complex work through sub-agents or orchestration, and its Status panel displays active tasks, sub-agents and workflows (Agent Workspace (opens in a new tab), built-in tools (opens in a new tab)). The prompt is the team brief.

1. Write the team brief for your review. Keep its gate, the line telling the agent to stop after extraction and wait for you, and point it at the same records and papers as your Session 1 benchmark.
2. Paste it into a Cherry Studio agent with the filesystem MCP scoped to the review workspace, and ask for the plan first: which sub-agents it will create, what each receives, which file each writes, and where it will stop. Tell it to begin only after you approve.
3. Let it run, and keep the Status panel open while it works.
4. At the extraction gate, retain the unedited output. Check the rows and fields required by your protocol against the PDFs, including their locators. Two rows can start a spot check, but do not establish that the rest are sound. Record unchecked rows and expand the check if you find a recurring problem. Save corrections in a separate reviewed copy.
5. Tell the agent which reviewed extraction file to use, then reply “continue” when the extraction gate is met.
6. At the critique gate, open the synthesis, contradictions, and critique files. Check disputed claims against original sources and compare the synthesis with notes/benchmark/08-synthesis-memo.md. For an approved AI-assisted check, the Output Mirror can help identify a passage to inspect.
7. Record what you accept, revise, or leave unresolved before authorizing further work. Ask whether the roles did different jobs and what still needed you.

Being easy to spawn does not mean the sub-agents are doing different work. Sub-agents built from copies of one prompt give you more opinions from the same model, not independent evidence; when they agree, it may only be because they were built alike. Keep both stops in the brief, after extraction and after critique, even when the run looks clean. Before adding a role, a second model or a scheduled rerun, put the design to the Arrangement Auditor.

In class: composing an agent team

The exercise that carried the first run was not in the materials, so here it is.

Before the session, each participant designs one agent for the shared literature review task: a role, a prompt, the files it may read, and what it must hand back. They bring the prompt.

In the session the class builds the team on one screen. The instructor opens Claude Code in the shared project and the group talks through the architecture first: which agents run in parallel, which wait, where the human gate sits. Then, one person at a time, each participant reads their agent in, the instructor relays it to Claude Code, and the class watches the team take shape. When the last agent is in, the team runs against the seed papers and the group reads the output together.

Three things happen in that hour that do not happen alone. The design conversation forces roles to be explicit enough to type. Every participant sees their own prompt inside a larger system and notices what it assumed. And the team runs while its authors are in the room, so the first failure is discussed rather than discovered later.

The second run aims one step further: participants run the team themselves. Two routes are open. In Claude Code, the design conversation becomes a written plan and the subagents are dispatched from it, which keeps every role inspectable. Or hand the same plan to a swarm-capable host such as Kimi's Agent Swarm (opens in a new tab), which in the author's runs reads a phased research plan, spins up its own agents per phase, shows each phase's output, and steers later phases from earlier results. The plan is the deliverable either way; how thorough it is decides how good the team can be.

For a step-by-step implementation of an SLR with Claude Code, including screening, extraction, and synthesis, see Building an SLR with Claude Code.

Pre-class setup for Session 4

Start from the workflow, not a list of installations. Check the trial in your course brief: a tool run, a human rehearsal, or design only. Human rehearsal and design-only work do not require an AI account, a knowledge base, or an MCP connection.

Finish the trial

Keep the instructions, supplied inputs, and unedited output for each performed role in separate run records. Record whether the extra role improved the checked result enough to justify its review time. A manual handoff tests that sequence; it does not demonstrate automated coordination.

For design only, check the proposed inputs, outputs, and human checkpoints, then record a next test. Mark results not performed. Follow your course brief for submission; the vault’s notes/README.md lists the records to keep. To move to real papers, follow readings/README.md and start separate working copies.

Beyond the guide

The workflows you design here can become the foundation for dissertation research, collaborative projects, and professional research practice.

The takeaway: agentic AI does not replace human expertise. It extends what the researcher can inspect, delegate, and verify.

Go deeper

Ready to explore advanced AI capabilities?

Related Resources

Navigation: Previous: Session 3 • Return to Case Study Overview