Guides

Opinionated guides for building with Threadline.

Popular use cases

AI Coding Assistant

Never asks "what language are you using?" again.

What Threadline remembers:

• Tech stack: languages, frameworks, tools, versions

• Code style: naming conventions (snake_case vs camelCase), comment density, functional vs OOP preference

• Active projects: repo names, current feature, open bugs

• Work patterns: prefers code-only vs explanation, includes tests by default, error handling style

How it works:

Before every response, Threadline injects the developer's stack and style preferences into the system prompt. The agent generates code that matches their conventions without being told. Style conflicts (e.g. switching from snake_case to camelCase) are detected and the agent confirms before updating the stored preference.

const { injectedPrompt } = await tl.inject(userId, `
You are a coding assistant. Use the user's stored stack 
and code style preferences when generating code. 
Match their naming conventions exactly.
`)

// After response — Threadline learns their style over time
await tl.update({ userId, userMessage, agentResponse })

AI Customer Support Agent

Knows each customer's history before they say a word.

What Threadline remembers:

• Customer tier: free, pro, enterprise
• Past tickets: issues raised, resolutions, escalations
• Recurring problems: patterns that keep coming up
• Communication style: formal vs friendly, patient vs frustrated baseline
• Product usage: features they use, integrations active

How it works:

When a returning customer opens a support chat, the agent already knows their tier, recent issues, and typical problems — and can open with a proactive offer instead of asking them to explain again. Sentiment is tracked across sessions so the agent adjusts tone accordingly.

const { injectedPrompt } = await tl.inject(userId, `
You are a customer support agent. The user's tier, 
history, and past issues are provided in context. 
Never ask them to repeat information you already have. 
Open proactively if you can predict their issue.
`)

AI Voice Agent

Feels like a real assistant — knows your routine.

What Threadline remembers:

• Speech preferences: pace, verbosity, confirmation style
• Recurring requests: "order coffee", "play news at 7am"
• Schedule patterns: extracted from "always" statements
• Environment: often in car, office, or noisy settings

How it works:

Voice agents benefit most from Threadline's recurring request detection. When a user says "I always listen to news at 7am", that gets stored. The next morning at 7am, the agent proactively offers the briefing without being asked. Tone and pace adapt to stored speech preferences.

const { injectedPrompt } = await tl.inject(userId, `
You are a voice assistant. Respond concisely — 
this will be converted to speech. Use the user's 
stored schedule and recurring requests to be proactive.
`)

Multi-Agent Handoff

User context travels between agents automatically.

What Threadline shares:

• Full structured context object (all 7 scopes)
• Each agent only sees the scopes it's been granted
• No explicit handoff code — context is just there

How it works:

Agent A and Agent B each have their own API key and agent ID, but both are granted access to the same user's context (with different scopes). When the user moves from Agent A to Agent B, Agent B calls inject() and already knows everything Agent A learned. No recap, no dropped context.

// Grant Agent B access to relevant scopes only
await tl.grant({
userId,
agentId: agentBId,
scopes: ["communication_style", "ongoing_tasks"]
})

// Agent B's system prompt is already enriched
const { injectedPrompt } = await tl.inject(userId, 
"You are taking over this conversation. " +
"Do not ask the user to repeat anything."
)

AI Sales Assistant

Sells like a senior rep who never forgets a detail.

What Threadline remembers:

• BANT: Budget, Authority, Need, Timeline per prospect
• Deal stage: Prospecting → Discovery → Proposal → Negotiation → Closed

• Objections: categorised as price, timing, competitor, or authority — and how each was handled

• Promised follow-ups: logged and surfaced next session
• Sentiment: enthusiasm, hesitation, urgency signals

How it works:

Before every sales call, the agent is briefed on the prospect's deal stage, open objections, and what was promised last time. It opens with the follow-up, not a cold intro. Objection patterns are tracked across deals to surface what works.

const { injectedPrompt } = await tl.inject(userId, `
You are a sales assistant. The prospect's deal stage, 
objections, and previous conversation are in context.
Always follow up on promised actions before anything else.
Handle objections using patterns that have worked before.
`)

AI Tutor / Learning App

Every session builds on the last.

What Threadline remembers:

• Curriculum coverage: topics taught, mastery level (1-5)
• Struggle points: where hints were needed, repeated mistakes
• Learning pace: progression speed, preferred format
• Goals: exam dates, target skill level

How it works:

Mastery scores update after every session based on performance — improving when the student solves independently, declining when they struggle. The next session automatically reviews topics with low mastery using spaced repetition intervals. The tutor never re-teaches what the student already knows.

const { injectedPrompt } = await tl.inject(userId, `
You are a tutor. The student's mastery levels and 
struggle points are in context. Review low-mastery 
topics first. Adapt your explanation style to what 
has worked for this student before.
`)

AI Writing Tool

Stops producing generic output from session one.

What Threadline remembers:

• Tone: formal, casual, humorous, professional
• Style: sentence length, vocabulary, use of metaphors
• Audience: who they typically write for
• Recurring topics and angles

How it works:

After a few sessions, Threadline has extracted a style fingerprint: average sentence length, formality level, vocabulary clusters. New drafts automatically match this fingerprint. The agent asks "more formal or casual?" only when the stored preference is ambiguous.

const { injectedPrompt } = await tl.inject(userId, `
You are a writing assistant. Match the user's stored 
tone and style exactly. Use their vocabulary level 
and sentence length. Write for their typical audience 
unless told otherwise.
`)

AI Financial Advisor

Every session fully briefed. No starting from scratch.

What Threadline remembers:

• Goals: retirement age, risk tolerance (1-10), liquidity needs
• Portfolio: holdings, allocation, recent changes
• Life events: marriage, home purchase, job change
• Past advice: recommendations given and whether acted on

How it works:

Each session opens with a brief recap of where things stand — portfolio, recent changes, open recommendations. The agent can proactively flag if stored risk tolerance conflicts with a new request, without the user having to restate their profile.

const { injectedPrompt } = await tl.inject(userId, `
You are a financial advisor. The user's goals, 
risk tolerance, and portfolio context are provided.
Always reference past advice before giving new 
recommendations. Flag conflicts with stored preferences.
`)

AI Health & Fitness Coach

Coaching that actually compounds.

What Threadline remembers:

• Goals: weight loss, muscle gain, endurance targets
• Workout history: exercises, sets, reps, weight, perceived exertion
• Injuries: past and current — never suggests conflicting exercises
• Nutrition: dietary restrictions, eating patterns
• Preferences: time of day, equipment available

How it works:

Every workout is logged. The next session plan is generated using progressive overload principles applied to stored history. If the user rated the last session "too hard", load reduces automatically. Injuries are permanent flags — the agent never suggests exercises that conflict with them.

const { injectedPrompt } = await tl.inject(userId, `
You are a fitness coach. The user's workout history, 
injuries, and goals are in context. Apply progressive 
overload to last session's data. Never suggest 
exercises that conflict with stored injuries.
`)

AI Onboarding Flow

Picks up exactly where the user left off.

What Threadline remembers:

• Progress: steps completed, steps pending
• Partial data: everything entered so far
• Abandon points: where they dropped off and when
• Preferences set: settings chosen during onboarding

How it works:

When a user returns after abandoning an onboarding flow, the agent resumes at the exact step they left — with all previously entered data pre-filled. If they abandoned at a complex step before, the agent proactively offers a guided walkthrough instead of presenting the raw form.

const { injectedPrompt } = await tl.inject(userId, `
You are an onboarding assistant. The user's progress 
and partial data are in context. Resume from where 
they left off. Never ask for information they've 
already provided.
`)

AI Recruiting Assistant

Never loses context between rounds.

What Threadline remembers:

• Candidate profile: resume highlights, skills, scores
• Pipeline stage: Applied → Screened → Interviewed → Offer → Hired
• Interview feedback: strengths, weaknesses, cultural fit
• Communication history: emails sent, response times
• Position requirements: what you're hiring for

How it works:

Before every candidate touchpoint, the recruiter agent is briefed on where the candidate is in the pipeline, what feedback has been given, and what follow-up is pending. Cross-candidate comparison uses stored position requirements to surface top fits automatically.

const { injectedPrompt } = await tl.inject(userId, `
You are a recruiting assistant. The candidate's 
profile, pipeline stage, and interview feedback 
are in context. Surface pending follow-ups first.
Compare against stored position requirements 
when ranking candidates.
`)

More ideas

• Vibecoding Platform — Remembers your stack, project structure, and preferences across every session.
• LLM Wrapper / AI Product — Slot Threadline in at the system prompt level. Personalisation without building memory infrastructure.
• Multi-Agent Pipeline — Context travels with the user across every agent in your pipeline. No repeated handoffs.
• AI Research Assistant — Remembers topics explored, sources used, and open questions across research sessions.
• AI Legal Assistant — Knows the client's case history, preferences, and prior advice. Every session fully briefed.
• AI Mental Health Companion — Remembers the user's journey, mood patterns, and coping strategies over time.
• AI Travel Planner — Knows your travel style, past trips, budget, and preferences. Plans that actually fit you.
• AI Financial Advisor — Remembers portfolio goals, risk tolerance, and previous advice. Builds on every session.

Building your first memory-aware chatbot

1. Model first, memory second. Start with a simple chat endpoint that takes system + messages and returns a reply. Prove out tone and behaviour before wiring in Threadline.

2. Introduce tl.inject() at the system layer.

   Replace your static system prompt with:

   typescript

   const { injectedPrompt } = await tl.inject(userId, basePrompt)

   Use injectedPrompt as the system message you send to your model. The response may include cacheHint for OpenAI 24h prompt caching.

3. Update context on every turn.
   typescript

   await tl.update({ userId, userMessage, agentResponse })

   This keeps the user's context fresh and lets Threadline learn their style, tasks, and preferences over time.

4. Expose the trust dashboard. Link users directly to /account so they can see, edit, and delete their context. This is a critical trust signal.

Multi-agent context sharing

Threadline is designed for multi-agent ecosystems: multiple assistants, tools, and products sharing a single user context.

1. Give every agent its own API key. Each agent gets a separate key (and thus a separate agent_id). This keeps audit logs and rate limits clean.

2. Scope grants narrowly. When sharing context between agents, use specific scopes:

   typescript

   await tl.grant({
   userId,
   agentId: supportAgentId,
   scopes: ["communication_style", "ongoing_tasks"],
   })

   Your support agent doesn't need access to emotional state or unrelated preferences.

3. Visualize access for users. Use the trust dashboard (or your own UI) to show which agents currently have access, what scopes they have, and when access expires.

User privacy best practices

• Minimize stored data. Only write to preferences or emotional_state when it materially improves the experience.
• Avoid raw PII where possible. Store references (e.g. "my partner", "my manager") rather than full names or emails, unless absolutely necessary.
• Respect deletions immediately. When a user hits "Delete all my context", treat it as final. Clear caches, revoke grants, and make sure all downstream agents handle the absence of context gracefully.
• Audit everything. Threadline's audit log is meant for humans. Consider exposing a subset of it in your own UI so users can see when agents read or wrote their data.

Migrating from Zep to Threadline

If you're already using Zep or another memory API, migration typically looks like this:

1. Map your schema to Threadline.
   • Zep's summary / facts → Threadline communication_style, domain_expertise, preferences.
   • Zep's tasks / todos → Threadline ongoing_tasks.

2. Backfill via a one-time script. Write a script that:

   • Iterates over your users.
   • Reads their existing memory from Zep.
   • Calls Threadline's POST /api/context/update or uses the admin SDK to seed context objects.

3. Flip your runtime integration. Replace Zep's read/write calls with:

   typescript

   const { injectedPrompt } = await tl.inject(userId, basePrompt)
   await tl.update({ userId, userMessage, agentResponse })

4. Turn off writes to Zep, keep reads temporarily.

   For a short window, you may want to read from both systems while only writing to Threadline, then fully cut over once you're confident in the migration.