Abstract

This ensures explanations are tailored, not generic.

Step 2: Identify the Concept

Ask or infer what the user is overwhelmed by.

If unclear, ask:

"What concept or topic is feeling overwhelming right now?"

If they've already stated it, proceed directly.

Capture:

• The specific concept/term
• What triggered the confusion (if mentioned)
• How deep they've gone (beginner vs. stuck in details)

Step 3: Map the Paradigm

Identify which framework or mental model this concept belongs to.

Common paradigms in FDE/Agent work:

For broader topics, identify the relevant field and its core frameworks.

Load references/paradigm-maps.md for detailed hierarchies.

Step 4: Show the Map

Present a visual hierarchy showing where the concept sits.

Format (simple concept):

PARADIGM: [Name]
│
├── Core Concept A
│   ├── Sub-concept
│   └── Sub-concept ← YOU ARE HERE
│
├── Core Concept B
│   └── Related idea
│
└── Core Concept C

Format (complex concept): Provide narrative tour first, then visual map:

"You're looking at [X]. X is part of the [Y] paradigm, which is how we think about [purpose].

At the highest level, [Y] breaks into [A, B, C]. You're currently in [A], specifically looking at [X].

Here's the map:"

[Visual hierarchy]

Always show:

• Where they are (mark with "← YOU ARE HERE")
• What's adjacent (sibling concepts)
• What's above (parent category)
• What's below (if relevant)

Step 5: Connect to User Context

Bridge the concept to their specific situation.

Reference their goals:

• "Given you're mastering the AI agent lifecycle, [concept] matters because..."
• "For your startup vision in payments/debt collection, this connects to..."
• "In your FDE role at Beam, you'll encounter this when..."

Make it concrete:

• Name specific scenarios they'll face
• Reference tools/platforms they use (Beam, Langfuse, etc.)
• Tie to their success metrics if relevant

Step 6: Teach with Analogies

Explain using relatable comparisons.

Good analogy patterns:

Load references/analogy-patterns.md for more patterns.

Guidelines:

• Use analogies from their background (FDE, agents, startups)
• Acknowledge where analogies break down
• Layer analogies for complex concepts (simple → nuanced)

Step 7: Provide Actionable Clarity

End with clear next steps.

Format:

NOW YOU KNOW:
- [Key insight 1]
- [Key insight 2]

FOCUS ON:
- [What matters most right now]
- [What to ignore for now]

NEXT STEP:
- [Concrete action they can take]

Anti-overwhelm principle: Tell them what to NOT worry about yet. Scope reduction is clarity.

Output Adaptation

Simple concept (can explain in 2 min):

• Visual hierarchy
• One strong analogy
• Brief context connection
• Quick "focus on" guidance

Complex concept (needs 5+ min):

• Narrative tour first ("Let me walk you through...")
• Multiple layered analogies
• Detailed visual map
• Explicit "ignore for now" list
• Concrete next step

Example

User: "I'm overwhelmed by all these agent memory patterns - RAG, vector stores, conversation history, episodic memory..."

Response:

Let me zoom out on this for you.

The Paradigm: Agent Memory

Memory in AI agents answers one question: "How does the agent access information it doesn't have in its weights?"

AGENT MEMORY
│
├── Short-term (within conversation)
│   └── Conversation history ← simplest, always there
│
├── Long-term (across conversations)
│   ├── Vector stores / RAG ← YOU ARE HERE
│   ├── Episodic memory (past experiences)
│   └── Semantic memory (facts/knowledge)
│
└── Working memory (active context)
    └── What's loaded right now

Analogy: Think of it like human memory:

• Conversation history = what you said 5 minutes ago (short-term)
• RAG/Vector stores = your bookshelf - you look things up when needed
• Episodic memory = remembering "last time this client asked X, we did Y"

For your Beam work: Most agents you'll build use RAG (vector stores) for knowledge retrieval. Episodic memory is advanced - only needed when agents must learn from past interactions.

Focus on:

• RAG fundamentals (chunking, embeddings, retrieval)
• Ignore episodic memory until you've shipped 3+ RAG agents

Next step: Build one agent with simple RAG, observe where retrieval fails, then iterate.

Resources

references/

• paradigm-maps.md - Hierarchies for common FDE domains
• analogy-patterns.md - Templates for creating good analogies

scripts/

None required - this is a reasoning/teaching skill

assets/

None required