Single Agent
One autonomous agent responsible for the entire task from start to finish. No delegation, no role separation, no coordination. Everything — reasoning, tool use, and memory — happens inside a single agent loop.
Structure
The agent receives a task, reasons over it, optionally uses tools and memory, and returns a result. The loop continues until the agent decides it's done.
Memory / State / Context
- Memory
- State
- Context
- Optional session memory within a conversation
- Optional long-term memory for cross-session persistence
- All memory owned and accessed by the same agent
- No memory sharing — single owner model
- Implicit and internal to the agent
- Reasoning traces and intermediate results live in the context window
- No external state tracking needed
- State resets between sessions unless externalized
- Full task instructions passed into one context window
- Entire conversation history available to the agent
- Context window is the hard ceiling on information capacity
- No context partitioning or scoping
Key Characteristics
- Minimal overhead — no coordination, routing, or delegation logic
- Easiest to implement — one prompt, one agent, one loop
- Full context visibility — the agent sees everything
- Fragile at scale — degrades as task complexity exceeds context window
- Single point of failure — no fallback if the agent gets stuck
When to Use
- The task is well-scoped and can be completed by one model in one pass
- You need the simplest possible architecture
- Context window is sufficient for the entire task
- Low latency matters more than task decomposition
- You're prototyping and don't need multi-agent coordination yet