agentica-infrastructure

Reference guide for Agentica multi-agent infrastructure APIs

⭐2.2kstars🔀157forks📁View on GitHub🕐Updated Jan 10, 2026⬇️1downloads

When & Why to Use This Skill

The Agentica Infrastructure skill serves as a comprehensive API reference guide for developers building and managing complex multi-agent systems. It provides detailed specifications for coordination patterns—including Swarm, Pipeline, and Hierarchical models—alongside core infrastructure components like CoordinationDB and MemoryService. This skill enables the precise implementation of agent tracking, failure fallbacks, and shared state management to ensure robust, scalable, and observable AI agent workflows.

Use Cases

  • Architecting complex multi-agent workflows by selecting and implementing the correct coordination patterns, such as Swarm for parallel perspectives or Pipeline for sequential stages.
  • Implementing persistent agent tracking and debugging using the CoordinationDB and tracked_spawn APIs to monitor agent activities and detect orphan processes.
  • Developing custom orchestration logic by leveraging low-level primitives for consensus voting, result aggregation, and structured agent handoffs.
  • Managing shared state and long-term context across distributed agent networks using the Blackboard and MemoryService components for efficient communication.
nameagentica-infrastructure
descriptionReference guide for Agentica multi-agent infrastructure APIs
allowed-tools[Read]
user-invocablefalse

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/