A few years ago, the interesting question in AI-assisted research was whether a language model could reliably summarize a document. That bar has moved considerably. The question now is how to coordinate many agents working in parallel — each with its own context, its own sub-tasks — and make the overall system actually reliable.
A recent hands-on workshop building a financial research system on top of Claude Managed Agents (a hosted multi-agent platform from Anthropic) illustrates how several of those coordination challenges can be addressed in practice. The patterns that emerge are worth understanding on their own terms, independent of the specific platform.
The Map-Reduce Pattern for Agent Orchestration
The core orchestration structure is map-reduce: a “head of research” agent receives a list of companies to analyze, dispatches a separate long-running session per ticker (the map step), and then aggregates the returned scorecards into a consolidated view (the reduce step). Each per-ticker session can itself spin up sub-agents — a financial data extractor, a risk evaluator — running in parallel within that session.
This mirrors how research teams actually work: a lead analyst hands off discrete chunks of work, parallel analysis happens independently, results come back and get synthesized. The model is straightforward, but making it reliable in practice requires solving two problems the pattern alone does not answer: how do you know the work is actually done, and how do you prevent the same ground from being re-covered every time?
Self-Supervised Outcomes: A Quality Gate Without a Human in the Loop
The quality-gate mechanism here is worth pausing on. Rather than relying on the working agent to simply declare completion, a structured outcome definition can be attached to a session: a plain-language task description plus a rubric with specific criteria. When the agent believes it has finished, a separate evaluator sub-agent — independent of the working thread — checks the outputs against the rubric. If the evaluation fails, the agent retries; only when the rubric is satisfied does the session close.
This is self-supervision in a fairly literal sense: one language model evaluating another language model’s work. It carries real limitations — an evaluator built on the same underlying model carries the same blind spots, and a poorly written rubric simply sets the bar in the wrong place. But for structured, well-defined tasks like SEC filing analysis, where the rubric can specify exactly what a completed scorecard must contain, it provides a meaningful quality gate without a human reviewer on every run.
Shared Memory and Collective Learning
The memory model deserves its own consideration. Memory stores are persistent and shared across sessions — not a per-conversation scratchpad but a durable, API-accessible store any session can read from or write to. An agent analyzing a company’s latest quarterly filing records its findings; the next scheduled run checks the store first and skips what is already known.
There is also a concept the workshop calls “dreaming”: a retrospective process that analyzes transcripts and memories from multiple past sessions, then consolidates edge-case lessons into the shared memory store so future agents benefit from what earlier ones encountered. Currently limited to memory updates (with skills and agent prompts on the roadmap), even this scoped version represents a meaningful shift — the system compounds knowledge over time through structured reflection, not just through fine-tuning.
Skills as Versioned, Shared Artifacts
One structural decision that simplifies maintenance: descriptions of how to use a capability (an SEC data API, a calculation method, a domain-specific procedure) live as versioned artifacts shared across agents. Update a skill once — adding a new SEC form type, for example — and every future session that references it picks up the change automatically, with no need to re-deploy the agent itself.
This keeps the agent prompt focused on orchestration and delegates capability descriptions to a separately maintained layer — a cleaner separation than embedding all of that context directly into a monolithic system prompt.
What Holds Up, and What Is Still Missing
The patterns above — map-reduce dispatch, rubric-based self-evaluation, shared persistent memory, versioned capability descriptions — are not specific to any one platform. They represent a reasonably mature way of thinking about multi-agent coordination for research-type tasks: parallel work with defined quality gates, and a memory layer that compounds over time.
What is still absent, and notably on the roadmap, is budget control per session (token and cost caps) and the ability to fork a session mid-run to branch from a known state. Those gaps matter for production reliability. For now, the architecture suits scheduled, async, low-latency-tolerance work — the kind of overnight research pipeline where a team wants fresh analysis already waiting when the day starts.
That use case is already compelling. Tighter real-time control will make it more so, and the trajectory of the infrastructure suggests it is not far off.
Text summarized and optimized using Anthropic’s models and reviewed by a human.