cat $CLAUDE_PROJECT_DIR/.claude/skills/agentica-sdk/SKILL.md

## Agent Requirements
[What the agent should do]

## Scope/Tools
[What tools or functions the agent should have access to]

## Return Type
[What the agent should return - str, dict, bool, etc.]

## Persistence
[Whether the agent needs conversation memory]

## MCP Integration
[If the agent should use MCP servers]

from agentica import agentic

@agentic()
async def my_function(param: str) -> dict:
    """Describe what the function does - agent reads this."""
    ...

from agentica import spawn

agent = await spawn(
    premise="You are a [role]. You [capabilities].",
    scope={"tool_name": tool_fn}
)
result = await agent.call(ReturnType, "Task description")

from agentica.agent import Agent

class MyAgent:
    def __init__(self, tools):
        self._brain = Agent(
            premise="Your role and capabilities.",
            scope=tools
        )

    async def run(self, task: str) -> str:
        return await self._brain(str, task)

from agentica import spawn
import subprocess
import json

async def nia_search(package: str, query: str) -> dict:
    """Search library documentation via Nia."""
    result = subprocess.run(
        ["uv", "run", "python", "-m", "runtime.harness",
         "scripts/nia_docs.py", "--package", package, "--query", query],
        capture_output=True, text=True
    )
    return json.loads(result.stdout) if result.stdout else {"error": result.stderr}

async def perplexity_search(query: str) -> dict:
    """Web research via Perplexity."""
    result = subprocess.run(
        ["uv", "run", "python", "-m", "runtime.harness",
         "scripts/perplexity_search.py", "--query", query],
        capture_output=True, text=True
    )
    return json.loads(result.stdout) if result.stdout else {"error": result.stderr}

# Create research agent
research_agent = await spawn(
    premise="You are a research agent. Use nia_search for library docs and perplexity_search for web research.",
    scope={
        "nia_search": nia_search,
        "perplexity_search": perplexity_search
    },
    model="anthropic:claude-sonnet-4.5"
)

# Use the agent
findings = await research_agent.call(
    dict[str, list[str]],
    "Research best practices for Python async error handling"
)

@agentic(persist=True, model="openai:gpt-4.1")
async def stateful_assistant(message: str) -> str:
    """An assistant that remembers previous interactions."""
    ...

# First call
await stateful_assistant("I'm working on project X")

# Later call - remembers context
await stateful_assistant("What project am I working on?")

from agentica.agent import Agent

class ResearchCoordinator:
    def __init__(self):
        self._planner = Agent(premise="Plan research strategies.")
        self._researcher = Agent(
            premise="Execute research tasks.",
            scope={"web_search": search_fn}
        )
        self._synthesizer = Agent(premise="Synthesize findings into reports.")

    async def research(self, topic: str) -> dict:
        # Plan
        plan = await self._planner(list[str], f"Create research plan for: {topic}")

        # Execute each step
        findings = []
        for step in plan:
            result = await self._researcher(str, step)
            findings.append(result)

        # Synthesize
        report = await self._synthesizer(
            dict,
            f"Create report from findings: {findings}"
        )
        return report

$CLAUDE_PROJECT_DIR/.claude/cache/agents/agentica-agent/output-{timestamp}.md

# Agentica Agent: [Name]
Generated: [timestamp]

## Implementation

## Dependencies

## Usage Example

## Testing

``