1# Example: X-to-Book Multi-Agent System
2 
3This example demonstrates how the Agent Skills for Context Engineering can be applied to design a production multi-agent system. The system monitors X (Twitter) accounts and generates daily synthesized books from their content.
4 
5## The Problem
6 
7A user requested a multi-agent system that:
8- Monitors target X accounts daily
9- Extracts insights and patterns from tweets
10- Produces structured book output
11 
12This is a non-trivial agent system because:
13- High-volume data (hundreds of tweets per day)
14- Long-form output requiring coherence
15- Temporal awareness (tracking how narratives evolve)
16- Quality requirements (accurate attribution, no hallucination)
17 
18## Skills Applied
19 
20### 1. multi-agent-patterns
21 
22**Decision**: Selected Supervisor/Orchestrator pattern over peer-to-peer swarm.
23 
24**Reasoning from skill**:
25> "The supervisor pattern places a central agent in control, delegating to specialists and synthesizing results. The supervisor maintains global state and trajectory, decomposes user objectives into subtasks, and routes to appropriate workers."
26 
27**Application**: Book production has clear sequential phases (scrape → analyze → synthesize → write → edit) that benefit from central coordination. Quality gates between phases require explicit checkpoints.
28 
29**Failure mode addressed**:
30> "Supervisor Bottleneck: The supervisor accumulates context from all workers, becoming susceptible to saturation and degradation."
31 
32**Mitigation applied**: Raw tweet data never passes through Orchestrator context. Scraper writes to file system, other agents read from file system. Orchestrator receives only phase summaries.
33 
34### 2. context-fundamentals
35 
36**Decision**: Strict context budgets per agent with progressive disclosure.
37 
38**Reasoning from skill**:
39> "Context must be treated as a finite resource with diminishing marginal returns. Like humans with limited working memory, language models have an attention budget drawn on when parsing large volumes of context."
40 
41**Application**: Each agent has an explicit token budget:
42- Orchestrator: 50k (routing only)
43- Scraper: 20k (one account at a time)
44- Writer: 80k (one chapter at a time)
45 
46**Principle applied**:
47> "Progressive disclosure manages context efficiently by loading information only as needed."
48 
49**Application**: Book outline loads first (lightweight). Full chapter content loads only when Writer is working on that specific chapter.
50 
51### 3. memory-systems
52 
53**Decision**: Temporal Knowledge Graph over simple vector store.
54 
55**Reasoning from skill**:
56> "Vector stores lose relationship information... Vector stores also struggle with temporal validity. Facts change over time, but vector stores provide no mechanism to distinguish 'current fact' from 'outdated fact'."
57 
58**Application**: The system needs to answer queries like:
59- "What was @account's position on AI regulation in January?"
60- "Which accounts agree/disagree on crypto?"
61 
62These require relationship traversal and temporal validity that vector stores cannot provide.
63 
64**Architecture from skill**:
65> "Temporal knowledge graphs add validity periods to facts. Each fact has a 'valid from' and optionally 'valid until' timestamp."
66 
67**Application**: All relationships (DISCUSSES, AGREES_WITH, DISAGREES_WITH) have temporal validity periods.
68 
69### 4. context-optimization
70 
71**Decision**: Observation masking for tweet data.
72 
73**Reasoning from skill**:
74> "Tool outputs can comprise 80%+ of token usage in agent trajectories. Much of this is verbose output that has already served its purpose."
75 
76**Application**: Daily tweet volume could reach 100k+ tokens. This data is:
771. Processed by Scraper
782. Written to file system (not passed through context)
793. Read by Analyzer in chunks
804. Summarized before reaching Synthesizer
81 
82**Compaction trigger from skill**:
83> "Compaction is the practice of summarizing context contents when approaching limits."
84 
85**Application**: Phase outputs are compacted at 70% context utilization before passing to next phase.
86 
87### 5. tool-design
88 
89**Decision**: Three consolidated tools instead of 15+ narrow tools.
90 
91**Reasoning from skill**:
92> "The consolidation principle states that if a human engineer cannot definitively say which tool should be used in a given situation, an agent cannot be expected to do better."
93 
94**Application**: Instead of separate tools for `fetch_timeline`, `fetch_thread`, `fetch_engagement`, `search_tweets`, we implement one `x_data_tool` with an action parameter.
95 
96**Tool description pattern from skill**:
97> "Effective tool descriptions answer four questions: What does the tool do? When should it be used? What inputs does it accept? What does it return?"
98 
99**Application**: Each tool has explicit usage triggers, parameter documentation, and error recovery guidance.
100 
101### 6. evaluation
102 
103**Decision**: Multi-dimensional rubric with automated pipeline.
104 
105**Reasoning from skill**:
106> "Agent quality is not a single dimension. It includes factual accuracy, completeness, coherence, tool efficiency, and process quality."
107 
108**Application**: Five evaluation dimensions weighted by importance:
109- Source Accuracy (30%) - quotes verified against original tweets
110- Thematic Coherence (25%) - narrative flow
111- Completeness (20%) - theme coverage
112- Insight Quality (15%) - synthesis beyond restating
113- Readability (10%) - prose quality
114 
115**Human review trigger from skill**:
116> "Human evaluation catches what automation misses."
117 
118**Application**: Books scoring below 0.7 or with source accuracy below 0.8 are flagged for human review.
119 
120## Architecture Diagram
121 
122```
123┌─────────────────────────────────────────────────────────────────┐
124│                     ORCHESTRATOR AGENT                          │
125│  Context: 50k tokens (routing, checkpoints, no raw data)        │
126│  Pattern: Supervisor with file-system coordination              │
127└─────────────────────────────────────────────────────────────────┘
128         │              │              │              │
129         ▼              ▼              ▼              ▼
130┌─────────────┐ ┌─────────────┐ ┌─────────────┐ ┌─────────────┐
131│   SCRAPER   │ │  ANALYZER   │ │   WRITER    │ │   EDITOR    │
132│   20k ctx   │ │   80k ctx   │ │   80k ctx   │ │   60k ctx   │
133│ Per-account │ │ Per-account │ │ Per-chapter │ │ Per-chapter │
134└─────────────┘ └─────────────┘ └─────────────┘ └─────────────┘
135         │              │              │              │
136         ▼              ▼              ▼              ▼
137┌─────────────────────────────────────────────────────────────────┐
138│                     FILE SYSTEM STORAGE                          │
139│  raw_data/{account}/{date}.json                                  │
140│  analysis/{account}/{date}.json                                  │
141│  drafts/{book_id}/chapter_{n}.md                                 │
142└─────────────────────────────────────────────────────────────────┘
143         │
144         ▼
145┌─────────────────────────────────────────────────────────────────┐
146│                 TEMPORAL KNOWLEDGE GRAPH                         │
147│  Entities: Account, Tweet, Theme, Book, Chapter                  │
148│  Relationships: POSTED, DISCUSSES, AGREES_WITH, SOURCES          │
149│  All relationships have temporal validity periods                │
150└─────────────────────────────────────────────────────────────────┘
151```
152 
153## Key Patterns Demonstrated
154 
155| Pattern | Skill Source | Application |
156|---------|--------------|-------------|
157| Context isolation via sub-agents | multi-agent-patterns | Each agent has clean context for its phase |
158| File system as coordination mechanism | multi-agent-patterns | Avoids context bloat from shared state passing |
159| Progressive disclosure | context-fundamentals | Chapter content loads only when needed |
160| Temporal knowledge graph | memory-systems | Tracks evolving positions over time |
161| Observation masking | context-optimization | Raw tweets never enter orchestrator context |
162| Tool consolidation | tool-design | 3 tools instead of 15+ |
163| Multi-dimensional evaluation | evaluation | 5 weighted quality dimensions |
164 
165## Files
166 
167- [PRD.md](./PRD.md) - Complete Product Requirements Document
168- [SKILLS-MAPPING.md](./SKILLS-MAPPING.md) - Detailed mapping of skills to design decisions
169 
170## Using This Example
171 
172This example serves as a template for applying context engineering skills to new projects:
173 
1741. **Identify context challenges**: What are the volume constraints? What causes context saturation?
1752. **Select architecture pattern**: Based on coordination needs, choose supervisor, swarm, or hierarchical
1763. **Design memory system**: Based on query patterns, choose vector store, knowledge graph, or temporal graph
1774. **Apply optimization techniques**: Observation masking, compaction, progressive disclosure as needed
1785. **Build evaluation framework**: Define dimensions relevant to your use case
179 
180The skills provide the vocabulary and patterns; the application requires understanding your specific constraints.
181 
182