Session 4: Advanced Agentic Workflows

Agentic design is the architecture of thinking at scale.

We now turn to designing agentic systems 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.

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"): 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"): the "what can go wrong" guide. Learning from professional teams helps anticipate and solve common problems.
• Practical implementation ("Claude Code: Best practices"): the primary lab manual, with specific instructions and code patterns for hands-on work.
• Professional context ("From Scarcity to Abundance"): 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, built-in tools). 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. When it stops, check two extraction rows against the PDFs, every field and every locator, and correct extraction.md wherever it is wrong.
5. Reply "continue". Then open each sub-agent's output file; do not rely on the lead agent's summary.
6. Check the synthesis against notes/benchmark/08-synthesis-memo.md, and run the Output Mirror on one paragraph of it.
7. Ask two questions of the run: did the sub-agents do 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, 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

Before this session, please ensure your research environment is fully prepared:

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