Threads
Your conversation workspace. Everything you create stays.
A thread is where an agent executes a run: the conversation, context, tool calls, decisions, and artifacts it creates, from webpages and files to tables, documents, and maps. Everything persists so you can return to it later.
Where the work happens
Threads in Hyperagent are built for work: the agent reasons through the request, makes decisions, uses tools, and creates outputs in one persistent workspace.
Inside a thread, the agent can research, browse, inspect sources, run code, analyze files, call connected services, use skills and memories, and create finished artifacts: a pricing table, strategy document, webpage, image, video, audio clip, map, or deck. You can see what it did and what it made.
Nothing disappears. You can come back days or weeks later and everything is still there, organized and accessible.
What the agent can use
The outputs are what the agent creates. The capabilities are how it gets there. Inside a thread, the agent can use the tools, integrations, knowledge, and connected services available to it.
🔎Research the web
💻Run code and process files
🔌Use connected tools
🗺️Use location intelligence
🧠Bring in knowledge
📋Evaluate outputs
What the thread keeps
Think of a thread as two things in one place: the run log and the artifacts.
The run log is the path the agent took: your prompts, the agent's responses, tool calls, searches, browser sessions, code execution, and decisions made along the way.
The artifacts are what the agent creates. These include:
📄Documents
📊Tables
🌐Webpages
🖼️Images
🎬Videos
🔊Audio
🧑💼Talking-head avatars
🗺️Maps
📽️Slides
⚡HyperApps
The artifacts do not disappear when the conversation moves on. Anything the agent creates stays with the thread and also appears in your Library: the place where documents, tables, webpages, media, maps, apps, and files stay organized and ready to reuse.
What the agent creates in a thread depends on the context it can use. Some context is already there when the thread starts: the agent's identity, instructions, tools, and pinned references. Some context appears as the run develops, when the agent researches, searches its knowledge, or finds the right skill, memory, document, or table. And some context comes from you, when you point the agent at exactly what it should use.
How context enters
A thread doesn't need to carry every memory, document, skill, and project detail from the start. Hyperagent brings in the context the request calls for.
At the start, the agent brings its foundation: identity, instructions, tools, integrations, and pinned context. That gives the thread a clear starting point.
As the run develops, the agent can find more. It may surface a relevant memory, search for the right skill, pull in a document or table, or call on another agent. You can also steer the run by pointing it at the exact context you want used.
The result is a focused workspace. The agent brings in the right background as the run develops, instead of starting every thread overloaded with everything it might need.
How to get better output from a thread
-
Give the agent the shape of the output. Start with the outcome, audience, and constraints:
Create a one-page competitive brief on Acme for the sales team. Focus on where we win on pricing.
-
Bring source material into the thread. Upload the PDF, spreadsheet, screenshot, dataset, or other file you want the agent to inspect and use.
-
Bring in the right context directly. @ Mention the document, table, or skill you want the agent to use. For files and media, add the file or paste the URL. "Use the Q3 pricing table as the baseline" is stronger than "check our pricing."
-
Keep one body of context together. If the goal is still the same, stay in the thread. The context compounds; splitting one project across threads makes the agent rebuild the picture each time.
How long threads stay coherent
Every thread produces a Thread Context Document: the agent's notebook for that run. It belongs to one thread and helps the agent keep track of the facts, corrections, decisions, and plan details that matter while the run is still in progress.
The point is continuity. When a thread gets long, older messages may be summarized so the agent can keep working. Those summaries are useful, but they can smooth over exact details. If you corrected a valuation from $8B to $5.5B early in the conversation, the summary might say "the user corrected the valuation" without preserving the exact number. The Thread Context Document is where that $5.5B survives.
After compaction, Hyperagent brings the Thread Context Document back into the agent's working context. Project context, pinned docs, memories, and skills can also stay available through their own paths, so the agent doesn't have to rely only on old message text.
Thread Context vs. Persistent Memories
The Thread Context Document isn't the same as Hyperagent's memory. It's for "don't forget what we are doing right now in this thread." Persistent memories are for "remember this next time."
| Thread Context Document | Persistent Memories |
|---|---|
| Scoped to one thread | Carry across future threads for an agent |
| Updated by the agent while it works | Saved as long-term knowledge, usually with review or approval |
| Keeps the current run coherent | Helps the agent understand you and your work later |
| Stays with the thread | Surfaces again when relevant |
How threads become learning
A thread can produce more than finished artifacts. When a run reveals information worth keeping, you can turn that moment into a skill or memory the agent can use later.
The Actions menu lets you suggest learnings, build a skill, give feedback, or run an evaluation. This is how a useful thread can become a memory, a repeatable workflow, or a quality signal for the agent.
The distinction matters: the Thread Context Document keeps the current run coherent. Learnings help the agent improve beyond this one thread.
Thread FAQs
A thread is the workspace where an agent turns context into decisions, tool calls, and artifacts. It keeps the conversation, outputs, and Thread Context Document together, so long-running threads stay coherent and finished artifacts stay easy to return to.