Skip to main content
Let’s build something real: an AI coach that actually knows its users.

​
The Problem

Most AI coaching apps have the memory of a goldfish. Every session starts fresh: 
User: "I'm stressed about the project deadline"
Coach: "What deadline are you referring to?"
User: "...the one I've told you about for the past 3 weeks"
Even with conversation history, the coach doesn’t really know the user. It pattern-matches on recent messages but can’t access:
  • What actually works for them (psyche)
  • What they’re actively working on (goals)
  • The full arc of their journey (episodes)

​
The Persona Approach

With Persona, the coach has real context: 
# User opens the app
context = await persona.get_context(user_id, "coaching session")

# Coach knows immediately:
# - Active goal: "Ship auth feature by Friday"
# - Psyche: "Works best in morning, struggles after lunch"
# - Recent episode: "Felt overwhelmed yesterday, couldn't focus"

response = coach_llm(
    user_message,
    system=f"You're a productivity coach. Context: {context}"
)
Now the coach can say:
“I know you’ve got that auth feature deadline coming up Friday. Last time you felt this overwhelmed, breaking it into morning blocks really helped. Want to try that approach again?”
Real personalization, not generic advice.

​
Implementation

​
1. Ingest Coaching Sessions

After each conversation: 
async def log_session(user_id: str, messages: list):
    transcript = "\n".join([
        f"{m['role']}: {m['content']}" 
        for m in messages
    ])
    
    await persona.ingest(
        user_id=user_id,
        content=transcript,
        source_type="coaching_session"
    )
Persona extracts:
  • What they talked about (episode)
  • Any revealed preferences or struggles (psyche)
  • Any commitments or action items (goals)

​
2. Build Context-Aware Responses

On each session: 
async def get_coach_response(user_id: str, user_message: str):
    # Get full context
    context = await persona.rag_query(
        user_id=user_id,
        query=f"relevant context for: {user_message}"
    )
    
    # Generate personalized response
    response = await llm.chat([
        {"role": "system", "content": f"""
You're a personalized productivity coach.

{context}

Use this context naturally. Reference specific things 
the user has mentioned before. Acknowledge their patterns.
Don't be creepy about it - weave it in naturally.
"""},
        {"role": "user", "content": user_message}
    ])
    
    return response

​
3. Track Progress Programmatically

Use Ask to extract structured progress: 
async def get_weekly_summary(user_id: str):
    return await persona.ask(
        user_id=user_id,
        query="Weekly progress summary",
        output_schema={
            "goals_progressed": ["goal description"],
            "blockers_identified": ["blocker"],
            "patterns_observed": ["pattern"],
            "suggested_focus": "string"
        }
    )

​
What Makes This Different

Without Persona: 
User: "I can't focus today"

Coach: "Here are 5 tips for improving focus:
        1. Take breaks...
        2. Minimize distractions..."

(Generic advice anyone could give)
With Persona: 
User: "I can't focus today"

Coach: "Is it the afternoon slump again? I've noticed you 
        mentioned this a few times — you seem to consistently 
        lose steam after lunch. 
        
        Last week you tried doing creative work in the morning 
        and admin tasks after lunch. That seemed to work well 
        for the presentation you finished. Worth trying that 
        pattern again?"

(Specific, evidence-based, personalized)
The data was always there in the conversations. Persona just makes it accessible.

​
Results

With Persona, your coach can:
CapabilityHow
Remember historyEpisodes chain sessions together
Know preferencesPsyche accumulates patterns
Track goalsGoals persist and update
Measure progressAsk API extracts structured insights
Personalize deeplyContext-aware responses every time
The coach doesn’t just respond — it understands.

​
Try It

Start with the quickstart, then:
  1. Create a test user
  2. Ingest a few coaching session transcripts
  3. Query and see the context that comes back
  4. Build your first personalized response
The difference is immediate.