What is Agentica infrastructure?

A reference guide for the multi-agent coordination APIs used to build and coordinate agent work across patterns and primitives.

Which patterns are available?

Swarm, Pipeline, Hierarchical, Jury, GeneratorCritic, CircuitBreaker, Adversarial, ChainOfResponsibility, MapReduce, Blackboard, EventDriven.

Where is the API specification located?

In the skill directory under API_SPEC.md (see Full API Spec).

agentica-infrastructure

npx machina-cli add skill parcadei/Continuous-Claude-v3/agentica-infrastructure --openclaw

Files (1)

SKILL.md

3.0 KB

Agentica Infrastructure Reference

Complete API specification for Agentica multi-agent coordination infrastructure.

When to Use

Building multi-agent workflows with Agentica patterns
Need exact constructor signatures for pattern classes
Want to understand coordination database schema
Implementing custom patterns using primitives
Debugging agent tracking or orphan detection

Quick Reference

11 Pattern Classes

Pattern	Purpose	Key Method
`Swarm`	Parallel perspectives	`.execute(query)`
`Pipeline`	Sequential stages	`.run(initial_state)`
`Hierarchical`	Coordinator + specialists	`.execute(task)`
`Jury`	Voting consensus	`.decide(return_type, question)`
`GeneratorCritic`	Iterative refinement	`.run(task)`
`CircuitBreaker`	Failure fallback	`.execute(query)`
`Adversarial`	Debate + judge	`.resolve(question)`
`ChainOfResponsibility`	Route to handler	`.process(query)`
`MapReduce`	Fan out + reduce	`.execute(query, chunks)`
`Blackboard`	Shared state	`.solve(query)`
`EventDriven`	Event bus	`.publish(event)`

Core Infrastructure

Component	File	Purpose
`CoordinationDB`	`coordination.py`	SQLite tracking
`tracked_spawn`	`tracked_agent.py`	Agent with tracking
`HandoffAtom`	`handoff_atom.py`	Universal handoff format
`BlackboardCache`	`blackboard.py`	Hot tier communication
`MemoryService`	`memory_service.py`	Core + Archival memory
`create_claude_scope`	`claude_scope.py`	Scope with file ops

Primitives

Primitive	Purpose
`Consensus`	Voting (MAJORITY, UNANIMOUS, THRESHOLD)
`Aggregator`	Combine results (MERGE, CONCAT, BEST)
`HandoffState`	Structured agent handoff
`build_premise`	Structured premise builder
`gather_fail_fast`	TaskGroup-based parallel execution

Full API Spec

See: API_SPEC.md in this skill directory

Usage Example

from scripts.agentica_patterns.patterns import Swarm, Jury
from scripts.agentica_patterns.primitives import ConsensusMode
from scripts.agentica_patterns.coordination import CoordinationDB
from scripts.agentica_patterns.tracked_agent import tracked_spawn

# Create tracking database
db = CoordinationDB(session_id="my-session")

# Swarm with tracking
swarm = Swarm(
    perspectives=["Security expert", "Performance expert"],
    db=db
)
result = await swarm.execute("Review this code")

# Jury with consensus
jury = Jury(
    num_jurors=3,
    consensus_mode=ConsensusMode.MAJORITY,
    premise="You evaluate code quality",
    db=db
)
verdict = await jury.decide(bool, "Is this code production ready?")

Location

API spec: .claude/skills/agentica-infrastructure/API_SPEC.md Source: scripts/agentica_patterns/

Source

git clone https://github.com/parcadei/Continuous-Claude-v3/blob/main/.claude/skills/agentica-infrastructure/SKILL.mdView on GitHub

Overview

This skill provides a complete API specification for the Agentica multi-agent coordination infrastructure. It covers pattern classes, core infrastructure components, and primitives used to build, orchestrate, and debug agent systems. It also points to the official API_SPEC for deeper technical details.

How This Skill Works

Each pattern class is documented with its purpose and a key method (e.g., Swarm .execute, Jury .decide). Core infrastructure components and primitives are listed with their associated files and roles to help you implement and extend patterns. The guide links to API_SPEC.md for the full technical spec.

When to Use It

Building multi-agent workflows with Agentica patterns
Need exact constructor signatures for pattern classes
Understand the coordination database schema
Implementing custom patterns using primitives
Debugging agent tracking or orphan detection

Quick Start

Step 1: Create CoordinationDB(session_id=\"my-session\")
Step 2: Instantiate a pattern (e.g., Swarm) with db and perspectives
Step 3: Invoke the pattern method (.execute or .run) and read results

Best Practices

Start by selecting a pattern class that matches your workflow (Swarm for parallel, Pipeline for sequential)
Consult CoordinationDB and coordination.py to understand state tracking
Use HandoffAtom and tracked_spawn for reliable handoffs and auditing
Leverage primitives like Consensus and Aggregator to combine results
Enable observability with MemoryService and BlackboardCache

Example Use Cases

Create a CoordinationDB and run a Swarm with multiple perspectives
Execute a Jury consensus to validate a decision on code quality
Coordinate tasks using MapReduce with query chunks
Debug orphan agents via tracked_spawn and coordination records
Share state across agents with a Blackboard and event-driven patterns

Frequently Asked Questions

Add this skill to your agents