Core Abstractions

The building blocks every agent system composes. Framework-agnostic primitives.

1. Tools / Actions

Tool Definition

class Tool:
    name: str                    # Unique identifier
    description: str             # For LLM understanding (critical!)
    parameters: JSONSchema       # Input validation + LLM guidance
    returns: JSONSchema          # Output structure
    async: bool                  # Blocking vs non-blocking
    idempotent: bool             # Safe to retry
    side_effects: list[str]      # "write", "delete", "charge", "external"

Tool Categories

Tool Design Principles

1. Single responsibility — One tool, one purpose
2. Descriptive names — search_web not google
3. Rich descriptions — Include when to use, examples, edge cases
4. Strict schemas — Enums over strings, required fields, constraints
5. Idempotency keys — For non-idempotent operations
6. Timeouts — Every tool needs a deadline
7. Observability — Structured logs: tool, input, output, latency, error

Function Calling Standards

2. Memory Systems

Memory Taxonomy

Memory Operations

class Memory:
    def write(self, content: str, metadata: dict) -> MemoryID
    def read(self, query: str, k: int = 10) -> list[Memory]
    def update(self, id: MemoryID, content: str)
    def delete(self, id: MemoryID)
    def consolidate(self) -> None  # Compress, deduplicate, extract patterns

Implementation Patterns

Memory Architectures

• MemGPT — Virtual context management, paging to disk
• Generative Agents — Reflection → importance → retrieval
• Mem0 — Graph-based, entity-centric
• LangGraph Checkpointer — Serializable state snapshots
• Zep — Long-term memory service, temporal queries

3. Planning & Reasoning

Planning Approaches

Planning Representations

# Linear plan
plan = [
    Step(id=1, tool="search", args={...}, depends_on=[]),
    Step(id=2, tool="analyze", args={...}, depends_on=[1]),
    Step(id=3, tool="write", args={...}, depends_on=[2]),
]

# DAG plan (parallelizable)
plan = DAG(
    nodes={1: Step(...), 2: Step(...), 3: Step(...)},
    edges=[(1, 2), (1, 3)]  # 2, 3 can run parallel after 1
)

Replanning Triggers

• Tool failure / error
• Observation contradicts assumption
• New information discovered
• Time/resource budget exceeded
• Human intervention

4. Reasoning Patterns

Chain-of-Thought (CoT)

Question: ...
Reasoning: Step 1... Step 2... Step 3...
Answer: ...

• Zero-shot: "Let's think step by step"
• Few-shot: Exemplars with reasoning
• Auto-CoT: Cluster questions → generate reasoning

Advanced Reasoning

Reasoning Budgets

ReasoningBudget:
    max_steps: int = 10
    max_tokens: int = 4000
    max_time_seconds: int = 30
    max_tool_calls: int = 20

5. Perception (Multimodal Input)

Input Modalities

Context Construction

def build_context(task, memory, tools, system_prompt):
    return [
        SystemMessage(system_prompt),
        *memory.retrieve_relevant(task, k=5),
        *tool_schemas(tools),
        UserMessage(task),
    ]

Context Prioritization

1. System prompt (always)
2. Task/goal (always)
3. Relevant memory (semantic search)
4. Tool schemas (available actions)
5. Recent history (sliding window)
6. Supplemental (docs, examples — if space)

6. Goals & Evaluation

Goal Representation

class Goal:
    description: str              # Natural language
    success_criteria: list[Criterion]  # Checkable conditions
    constraints: list[Constraint]      # Budget, safety, style
    priority: int                 # For multi-goal
    deadline: datetime | None     # Time-bound

Criterion Types

7. Execution Environment

Sandbox Requirements

Popular Sandboxes

8. Communication Protocols

Agent-to-Agent (A2A)

{
  "protocol": "a2a/1.0",
  "message_id": "uuid",
  "from": "agent://researcher",
  "to": "agent://coder",
  "performative": "request",  // request, inform, query, propose, accept, reject
  "content": {
    "task": "Implement user auth",
    "context": {...},
    "constraints": [...]
  },
  "reply_to": "agent://researcher",
  "expires": "2024-01-15T10:30:00Z"
}

Performatives (FIPA-inspired)

Related Notes

• LLM Fundamentals — Model capabilities enabling these abstractions
• Agent Definitions — Agent taxonomy using these blocks
• Function Calling — Provider-specific implementations
• MCP Protocol — Standardized tool protocol
• Memory Systems — Memory deep dive
• Checkpointing — Serializable execution state
• Communication Protocols — A2A deep dive
• Single Agent Patterns — Patterns composing these abstractions

Sources: LangChain/LangGraph/AutoGen/CrewAI source code, "Generative Agents" (Park et al.), "ReAct" (Yao et al.), "Reflexion" (Shinn et al.), "MemGPT" (Packer et al.), FIPA ACL, MCP spec, Anthropic/ OpenAI function calling docs, sandbox security papers.