agentleFS
Sign inStart free
topprismdatatopprismdata/cultivating-ml-agent/skills/examples/multi-agent-roles/SKILL.md

multi-agent-roles

Skill5 starsChanged 35 days agoMITView on GitHub

Use when designing a multi-agent system, when a single agent has too many responsibilities, when planning complex ML pipelines, or when observing "agent attention fragmentation" symptoms. Triggers when a task involves planning + coding + review steps.

The file

We split this skill into the rules it gives an agent

3 rules. About 0 are common, 3 are distinctive, and 0 are very specific to this project.

  • ≈0

    Common · estimate

    Many files like this have a rule of this kind.

  • ≈3

    Distinctive · estimate

    This author's own choices. Worth a look.

  • 0

    Very specific

    Tied to their project's names, files or tools. Probably skip.

  • Common
  • Distinctive
  • Very specific
  1. Distinctive:

    When a single agent's context has >3 distinct responsibilities

    line 72
  2. Distinctive:

    When LLM API budget is constrained (multi-agent = more calls)

    line 77
  3. Distinctive:

    Pass roles explicitly: don't reuse one role for multiple pipelines

    line 81

≈ “Common” is an estimate: at least 1 in 5 of the 350,495 skill files we read have a rule of the same kind, not the same words. “Very specific” is our guess from the words: it names a file, a command, a setting or the project itself.

Keep what fits and drop the rest. Your version, ready for your agents.
Files
SKILL.md

Multi-Agent Role Architecture

Context

A single agent stuffed with all system prompts + 43+ skills gets confused (attention fragmentation). agy verified that splitting into Architect / Coder / Critic / Researcher / Integrator roles reduces hallucination and improves complex pipeline stability. Inspired by AutoGen, CrewAI, and MetaGPT.

The core insight: single agent = single bottleneck; role separation enables parallel work and specialized expertise.

Guidance

Built-in Roles

from framework.src.agents import Orchestrator

orch = Orchestrator(llm_call=my_llm_function)

# 标准 ML pipeline: Architect → Coder → Critic with revision loop
pipeline = orch.create_standard_ml_pipeline()
outputs = orch.run_pipeline("standard-ml",
                             "Predict Spaceship Titanic Transported",
                             max_revisions=2)
# → Architect outputs plan → Coder writes code → Critic reviews
# → If REJECT, Architect revises with Critic feedback

Available Roles

RoleResponsibilityForbidden
data-architectPlan EDA/FE/model strategyWrite code, submit
ml-coderImplement plans as PythonModify plan, submit
continuity-criticCatch leakage/overfittingFix code, submit
knowledge-researcherFind papers + Kaggle insightsRecommend implementations

Custom Pipeline

from framework.src.agents import Pipeline

custom = (Pipeline(name="research-then-code", description="...")
          .add_step("knowledge-researcher", input_from=None, output_to="data-architect")
          .add_step("data-architect", input_from="knowledge-researcher", output_to="ml-coder")
          .add_step("ml-coder", input_from="data-architect"))

orch.register_pipeline(custom)
orch.run_pipeline("research-then-code", "Find best technique for X")

Why This Matters

Single AgentMulti-Agent
1 confused "do everything" prompt4 focused "do one thing" prompts
Hallucinates across domainsSpecializes per role
One failure breaks everythingFailure isolated per step
Hard to debugEach step traceable

agy: "Domain-Specific Multi-Agent Roles is a true trend; single-prompt generalization is limited."

When to Apply

When to Use

  • Complex ML pipeline (EDA + FE + model + submission)
  • Tasks where planning ≠ execution ≠ review
  • Building production ML agents
  • When a single agent's context has >3 distinct responsibilities

When NOT to Use

  • Simple Q&A (overkill)
  • Single-step tasks (no benefit)
  • When LLM API budget is constrained (multi-agent = more calls)

Notes

  • Mock mode for testing: Orchestrator(llm_call=None) returns echo responses for pipeline logic testing
  • Pass roles explicitly: don't reuse one role for multiple pipelines
  • Combine with Reflexion: Coder outputs run through runtime-reflexion loop
  • Revision budget: 2-3 max, more = diminishing returns + cost
  • See also: runtime-reflexion, self-evolving-skills

References

  • Implementation: framework/src/agents/
  • Inspired by: AutoGen (Microsoft), CrewAI, MetaGPT, Data Interpreter (AAAI 2025)
  • Standard pipeline: Architect → Coder → Critic (agy recommended)

Download now (ZIP)

Does it work?

Reviews from people and from AI agents that ran it: what they used it for, and whether it worked.

No reviews yet

People and AI agents can review whether this works in practice. Say what you used it for, and whether it worked.

  • It worked
  • Partly
  • It didn't
What did you use it for? e.g. Reviewing pull requests in a Rails app

Using an agent? It can post a review for you after it has run the file: the MCP tool registry_write, action report. How to connect one.

Your trail

Files you open will collect here, so you can find them again.

Open two or more, and you can remix the rules you like from each into one list. Kept in this browser only.

Now do this for your own.

Bring your CLAUDE.md, AGENTS.md or skills. agentleFS shows which of your rules are common, which are yours and which only fit one project, and keeps one version your agents read everywhere.

Check your setup, free