# Your first thread

Source: https://www.hyperagent.com/docs/lessons/your-first-thread

Learn how to start a thread with the right context, guide it with specific feedback, and know when to begin fresh.

Treat every new thread as a briefing, not a conversation. A thread is a self-contained working session that starts fresh every time. The quality of what comes out is directly proportional to the specificity of what goes in.

## The four ideas that make threads productive [#the-four-ideas-that-make-threads-productive]

### Every thread starts fresh [#every-thread-starts-fresh]

A thread is a self-contained working session with a specific agent. The agent brings its system prompt, skills, and memories into every new thread, but it carries no memory of previous threads. The agent has zero awareness of anything from any other thread.

People often assume the agent remembers the last conversation the way a colleague would. But the independent model is intentional. You tell your agent exactly what to remember, so it can pull in that information while still maintaining enough room in its context to process the current task.

**The design is intentional.** Each thread is reliable because it's isolated: no carryover from other projects or stale assumptions. You control exactly what the agent knows by controlling what you put into the thread.

### Everything in the thread stays available [#everything-in-the-thread-stays-available]

Within a single thread, every message you send, every file you upload, every search result the agent retrieves, and every output the agent produces stays available for the duration of the session. Every exchange builds context.

This means the agent's work improves as the thread develops. Early in the thread, the agent has only your opening message. By the fifth or sixth exchange, the agent has accumulated research, your feedback, intermediate outputs, and your clarifications.

**The practical implication:** A vague start to the thread forces the agent to spend several exchanges asking clarifying questions. A specific one lets it start producing useful work immediately.

### Four elements of a strong opening message [#four-elements-of-a-strong-opening-message]

The opening message sets the trajectory for the entire thread. Strong opening messages share four elements:

**1. Who you are.** Establish your role and what your work involves. "Marketing manager running paid campaigns across three platforms" gives the agent a clear mental model.

**2. The specific task.** Describe the job concretely. "Pull last week's spend data, compare against quarterly targets, flag outliers" is actionable immediately.

**3. What good looks like.** Define the format, audience, and delivery channel. "A summary with recommendations, delivered in Slack to my director."

**4. Where to start.** Give the agent a concrete first step. "Start by pulling the data and flagging the outliers" removes all ambiguity.

**You don't need all four every time.** But the more context you include, the better output you'll receive. The pattern: who you are, what you need, what good looks like, where to start.

### You're setting the agent up to do a job [#youre-setting-the-agent-up-to-do-a-job]

The most productive way to use a thread: provide context upfront, let the agent produce a first draft, then give specific feedback. "Add Q1 pricing data to the competitor section. Cut the executive summary to three sentences."

Each round of feedback adds context the agent uses for everything after. By the third revision, the agent has internalized your preferences, your standards, and the specific requirements of the deliverable.

**A common mistake: abandoning the thread too early.** The first output works from a limited context. The second and third outputs, informed by your feedback, are where the real value appears.

## How a structured briefing changes the entire session [#how-a-structured-briefing-changes-the-entire-session]

| Dimension                  | Vague Opening                                           | Structured Briefing                                             |
| -------------------------- | ------------------------------------------------------- | --------------------------------------------------------------- |
| First response             | Generic clarifying questions                            | Immediate useful work                                           |
| Exchanges to useful output | 5 or more rounds of back-and-forth                      | 1 to 2 exchanges                                                |
| Context quality            | Thin and reactive; agent is guessing                    | Rich and proactive; agent understands the job                   |
| Agent understanding        | Surface-level; no sense of role, audience, or standards | Deep and specific; role, task, output, and first step are clear |
| Likely user reaction       | "This agent isn't useful"                               | "This saved me an hour"                                         |

*The difference between these two outcomes is one well-structured opening message. The agent's capability is identical in both cases.*

## Key vocabulary [#key-vocabulary]

A self-contained working session with a specific agent. Each thread starts fresh with no memory of previous threads. Everything said and produced within the thread stays available for the duration of the session.

The instructions that define an agent's role, expertise, and behavior. The system prompt is part of what the agent brings to every new thread, along with its skills and memories.

The accumulated information within a thread that the agent can draw on: messages, files, search results, feedback, and intermediate outputs. Context compounds over the life of a thread.

A setting that tells the agent to lay out its intended approach (steps, sources, structure) before executing. Valuable for complex, multi-step tasks and for specifying new agents.

## FAQs [#faqs]

Thread independence is an intentional design decision. Each thread is a self-contained working session. The agent carries its skills, memories, and system prompt into every new thread, but nothing from a previous thread's conversation transfers. This prevents context bleed, stale assumptions, and confusion between different projects. The result is that each working session starts clean and produces reliable output regardless of what happened in other threads. When the agent draws a blank about something from a prior thread, it's working as designed. You control what the agent knows in any given session by controlling what you put into the thread.

Context compounds within a thread. When you start with a specific, structured opening message, the agent has enough information to begin producing useful work immediately. Each subsequent exchange builds on that foundation. When you start with a vague message like "help me with my work," the agent spends its first several responses asking clarifying questions, and the information it gathers is reactive rather than strategic. The trajectory of the entire session is set by the quality of the opening message. The recommended framework: establish who you are, describe the specific task, define what good output looks like, and give the agent a concrete first step.

Start fresh when the job has changed. Stay when you're iterating on the same deliverable, even across multiple days. Refining a brief and want to adjust formatting? Stay: the agent already has the research and your feedback. Finished that brief and need a campaign checklist? Start a new thread with new requirements. Other signals to start fresh: the topic has shifted entirely, the thread has gotten long and cluttered, or you want a clean searchable record for a specific deliverable.

Plan Mode tells the agent to lay out its intended approach before executing: the steps, sources, and structure of the deliverable. You review the plan, adjust it, and approve before any work begins. This is especially valuable for complex tasks with multiple steps or outputs, because it surfaces misunderstandings at the planning stage rather than after the agent has already produced a deliverable based on wrong assumptions. Plan Mode is also a powerful strategy for specifying a new agent: start a fresh thread, describe the agent's purpose, iterate on its behavior, and use the thread as a design surface before saving the result as a named agent.

## Summary [#summary]

Start your first thread with a real piece of work, something you would normally spend an hour on. Each blank thread is an opportunity. The more context you give, the faster the agent reaches useful output.