Chat History, Memory & Thread Context

Every conversation you have with your Agency Hero agent is more than a one-off exchange — it’s a thread that persists across sessions, carries structured context, and feeds into the agent’s understanding of what you’re working on. This article explains how that all works, what happens to context over time, and how to get the best results from your threads.

What Is a Thread?#Copy link

In Agency Hero, a thread is a persistent conversation tied to a specific context — usually a workspace, meeting, task, or item in your A-Box. Threads live in the sidebar (the Threads Rail) and you can return to any of them at any time.

Each thread:

• Persists indefinitely — your conversation history is stored in the database and available whenever you come back
• Carries its own message history — every message you send and every response the agent gives is saved
• Has a lifecycle — active threads close after 1 hour of idle time and auto-archive after 7 days of inactivity
• Can span multiple sessions — closing your browser, navigating away, or coming back days later doesn’t break the thread

You can have up to 10 threads open as tabs at the same time (in Work Mode). Each tab is an independent thread with its own history and context.

How Thread Persistence Works#Copy link

During a session#Copy link

While you’re actively chatting, the agent runs as a live workflow. Every message you send and every reply the agent generates is saved to the database as it happens — there’s no risk of losing work if you navigate away or close the tab.

When a thread goes idle#Copy link

After 1 hour of no activity, the thread’s underlying workflow closes. Before it does, the system automatically generates a conversation summary — a concise LLM-generated digest of what was discussed, decisions made, tool results, and context you established. This summary is stored alongside the thread.

When you return to an old thread#Copy link

When you click a thread in the sidebar and send a message, the system picks up exactly where you left off:

1. The workflow restarts for that conversation
2. The saved summary is loaded as context
3. Your most recent messages are loaded, working backward until the available context budget is filled
4. The agent processes your new message with all of that history in hand

From your perspective, the conversation just continues — the agent doesn’t “forget” what you talked about, even if the thread has been closed for days.

Auto-archiving#Copy link

Threads that have been closed and idle for 7 days are moved to an Archived section in the Threads Rail. Archived threads aren’t deleted — you can still find them, read the history, and continue chatting. Sending a message in an archived thread automatically unarchives it.

What “Thread Context” Means#Copy link

The agent doesn’t see your entire conversation history as one giant block of text. Instead, it works within a context window — the maximum amount of information an AI model can process at once.

Here’s how context is managed in each thread:

The system calculates how many messages fit within the budget and loads them from newest to oldest. In practice, the agent always has your most recent exchanges and a summary of older history — so continuity feels natural even in long threads.

What the agent knows within a conversation#Copy link

Within an active thread, the agent:

• Knows everything said in the messages loaded into its context window
• Has awareness of older parts of the thread through the conversation summary
• Knows the current workspace you’re working in (automatically updated as you navigate)
• Can use tools to look up tasks, meetings, knowledge, and other live workspace data
• Does not automatically know what’s happening in other threads (those are separate conversations)

Two Kinds of Memory: Thread Context vs. Agent Memory#Copy link

It’s worth distinguishing between two distinct things the agent can “remember”:

1. Thread context (conversation history)#Copy link

This is the message-by-message record of a specific thread. It’s scoped to a single conversation and is what you see in the chat UI. The agent uses this to follow the flow of your discussion, remember what you agreed on earlier in this thread, and avoid repeating itself.

Thread context is temporary in scope — it lives within this conversation and doesn’t automatically carry into other threads.

2. Agent persistent memory (the memory scratchpad)#Copy link

The agent also has a persistent memory scratchpad that exists across conversations. This is a markdown document the agent maintains to record things it has learned about you and your work over time — things that should inform every future interaction, not just the current thread.

Examples of what goes into persistent memory:

• Preferences you’ve expressed (“always use bullet points”, “prefer concise summaries”)
• Decisions your team has made (“we’re targeting mid-market agencies this quarter”)
• Context about ongoing initiatives (“the Acme deal is in negotiation”)
• Patterns the agent has noticed (“user prefers tasks broken down by owner”)

This memory is stored separately from your conversation history. The agent reads it at the start of each interaction and updates it when something important comes up — no matter which thread you’re in.

Key difference:

You don’t need to manage either of these directly — the agent handles both. But it’s useful to know that if you tell the agent something important once (“we no longer use HubSpot”), it can record that to its memory scratchpad so you don’t have to repeat yourself in every thread.

Context Degradation in Long Conversations#Copy link

The longer a thread gets, the more the context window fills up. Here’s what happens and how to recognize it:

What causes context degradation#Copy link

• Long threads with dense exchanges — many messages means older context drops out of the window
• Large tool outputs — search results, meeting summaries, and task lists take up token space
• Complex multi-step tasks — extensive back-and-forth reasoning accumulates quickly

The agent’s context window for most models (like GPT-4o) is 128,000 tokens — which is substantial. But in practice, the system reserves space for the system prompt, workspace context, and output buffer, so the actual space for messages is smaller.

Signs the context window is getting full#Copy link

• The agent seems to “forget” something you mentioned early in the conversation
• You have to re-explain context that you already provided
• The agent asks clarifying questions about things it should already know
• References to earlier parts of the thread become vague or inaccurate

How the system handles it#Copy link

The system automatically manages this by:

1. Prioritizing recent messages — if not all messages fit, older ones are dropped first
2. Using the conversation summary — the LLM-generated summary covers the “dropped” history in condensed form
3. Loading context fresh each turn — workspace data (tasks, meetings, etc.) is loaded fresh rather than accumulating

The agent won’t crash or throw an error when the window fills — it will gracefully work with what fits. But the quality of its responses for references to older parts of the conversation may decline.

What you can do#Copy link

• For important facts, ask the agent to remember them — say something like “Please note this in your memory” and the agent will update its persistent scratchpad
• Start a fresh thread — for a genuinely new topic or workstream, a clean thread gives the agent a fresh, uncluttered context to work with
• Summarize progress yourself — at the start of a long session, a brief recap (“We’ve decided X, we’re now working on Y”) helps ground the agent quickly

When to Start a Fresh Thread#Copy link

Thread continuity is powerful, but it’s not always the right tool. Here’s how to think about it:

Keep the same thread when…#Copy link

• You’re continuing work on the same project, topic, or task
• You want the agent to remember context from earlier in the conversation
• You’re iterating on something the agent helped you draft or research
• The thread has built up useful context (decisions, research, agreements) that’s still relevant

Start a new thread when…#Copy link

• You’re switching to a genuinely different topic — a new deal, a different client, an unrelated task
• The current thread has gotten very long and you’re noticing the agent losing track of things
• You want a clean slate — no prior assumptions, fresh workspace context, no accumulated history
• You’re starting a new phase of a project where past context would create noise rather than signal
• You’re in a different workspace and want the conversation grounded in that context from the start

How to start a new thread#Copy link

Click the + icon in the Threads Rail or at the top of the chat panel. This creates a fresh conversation. You can also start a new thread from any workspace, meeting page, or task — the thread will be initialized with context from wherever you are.

Your old threads remain accessible in the sidebar. You can always go back.

Best Practices for Working with Threads#Copy link

Name your threads. Threads get auto-titled based on the first exchange, but you can rename them. A clear name makes it easy to find the right thread later.

Use threads as workspaces for ongoing projects. A thread for “Q3 Content Strategy” or “Acme Deal Research” can carry months of useful context. Don’t feel like you need to start fresh just because time has passed.

Tell the agent when something is worth remembering. If you establish a preference, a decision, or a key fact, say “please remember this” or “add this to your memory.” The agent will update its persistent scratchpad so it carries forward across all future conversations.

Don’t worry about idle time. Threads don’t disappear when you close your browser or come back after a week. The conversation summary handles continuity, and the agent will pick up the thread naturally.

Start a fresh thread for fresh thinking. If you want the agent to approach something without any prior assumptions from a long thread, a new conversation is the right call. Think of it like opening a new document — the old one is still there, you’re just not working in it right now.

Archived threads are still searchable. Even after a thread auto-archives, its summary is indexed and can surface as relevant context in future conversations. Your past work doesn’t disappear — it becomes part of the system’s broader awareness of your work.

Quick Reference#Copy link