# Threads Source: https://www.hyperagent.com/docs/concepts/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 [#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 [#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. Search the open web, use semantic search, open a browser, inspect pages, collect sources, and find reference images. Write and run Python, Node, or Bash in a persistent sandbox. Use it for analysis, file processing, API calls, rendering, and custom logic. Use integrations and MCP servers to work with services like Slack, Gmail, Google Drive, GitHub, Airtable, Notion, Salesforce, Databricks, and Snowflake. Geocode addresses, find places, calculate routes, generate maps, pull Street View imagery, check weather, and look up time zones. Search for relevant skills, memories, documents, and tables. Load methods and context when the request calls for them. Use rubrics to define what good looks like and check outputs against those standards. ## What the thread keeps [#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: Structured documents the agent can update over time. Scope them to a thread, share them across a project, or make them global. Every edit creates a version you can roll back to. Typed rows and columns that persist across conversations. The agent builds and updates them as it works. Export to CSV or JSON anytime. Published HTML pages the agent designs and writes: reports, dashboards, visualizations, and embedded maps. Edit and republish at the same URL. Visuals the agent can generate, revise, composite, and render with crisp text. Multiple models are available for different jobs. Short video clips with native audio. The agent can animate a still image, extend a clip, or keep scenes visually consistent across a sequence. Narration, voiceovers, and multi-speaker dialogue. Use a single voice or full conversations with different speakers. Presenter-style videos with a selected spokesperson and voice. Useful for updates, explainers, and sales enablement. Interactive maps with markers, routes, directions, Street View, aerial views, and weather. The agent can geocode addresses and find nearby places. Presentation decks the agent designs slide by slide. Keyboard, swipe, and dot navigation are built in. Interactive applications that can search the web, query tables, spawn agents, and fetch live data. The interactive counterpart to webpages. 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 [#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 [#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 [#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. 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 [#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. ## FAQs [#faqs] Point the agent at what it should use. Attach files directly, @ mention documents, tables, or skills, paste a URL, or state your constraints and requirements in plain language. The more specific you are, the less the agent has to guess. "Use the pricing table from the Q3 analysis" is better than "check our pricing." Keeping related context in the same thread also helps the agent build on what it already knows instead of starting cold. An agent is the configured teammate: its identity, instructions, tools, skills, and knowledge. A thread is one workspace where that teammate executes a run. One agent can participate in many threads. Your "Research Assistant" agent might have separate threads for competitor analysis, market sizing, customer interviews, and board prep. Yes. If you start a new conversation without selecting a named agent, Hyperagent uses the default AI. That works well for one-off tasks. For outcomes you expect to repeat, improve, or hand to a team, choose an agent so the thread starts with the right identity, tools, and context. No. A thread stays with the agent it started with. You can still update the agent while the thread is running. Add tools, connect integrations, attach skills, or change the agent's settings, and those updates are reflected on the next turn. If the agent tried to use Slack before it was connected, connect Slack, return to the thread, and keep going. Use `Cmd+K` to search for threads or agents. Search by the agent, thread title, topic, or the artifact you remember creating. It is the fastest way to get back to an old run without digging through the sidebar. Use a project when several threads belong to the same initiative: a launch, client account, research effort, internal process, or ongoing team workflow. Projects keep related threads together and give them shared context. Continue the same thread when the goal, context, or deliverable is still the same. Start a new thread when the goal changes, the old context is getting in the way, or you want a clean run for a new deliverable. If one thread starts holding multiple unrelated workflows, split the next one out. 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.