Memory

Memory helps an Agent carry useful lessons into later work. You can inspect what it remembers, correct a misleading note, and restore an earlier version if a change makes its work worse.

What belongs in memory

Keep guidance that should survive beyond one Task: an accepted example, a recurring mistake to avoid, a review condition, or a useful checklist. Leave one-off details and the full work history on the Task.

The Agent's Memories page shows guidance for that Agent's work. Projects, Goals, and Teams each have a Memories tab for lessons that apply to their work. Workspace memory holds guidance that applies throughout the workspace. Use Library documents for longer explanations and reference material, and keep secrets in Vault.

Each person in your workspace also has a Memories tab on their page under Humans in Workforce settings, for what they know, what they handle, and how they like to work. Agents suggest notes about a person, and Task Machine keeps notes about outside contributors under the name an Agent met them by. Notes Task Machine works out from a pattern, such as the hours someone is usually active, are marked Inferred until a person edits them.

A Task can supply selected notes about its creator, current reviewer, and people who commented directly on it. These notes help another Agent respect how you want work done, such as addressing the reader directly in an article. They are read-only context, with each person's notes kept separate. Imported or deleted comments establish no participation, and notes about inactive people and inferred availability patterns stay out of Runs.

This does not let an Agent browse everyone's notes or edit a person's memory. Chat and heartbeats do not receive Task participants' notes. An Agent can still look someone up when work needs a person and receive the notes that match that job.

How Agents use what they remember

An Agent receives selected notes when it starts work, rather than its whole memory. Always-on notes, marked to reach every applicable Run, come first. Relevant notes follow. Those notes show their dates so the Agent can check them against current evidence.

A decision between conflicting Project goals has one living always-on direction note. Its category reads Goal direction instead of Decision, with Always on shown separately. Other Decision notes keep their category.

Each new decision replaces that note, so the number of decisions never fills the standing guidance allowance. Every agent starting work in the Project receives the default direction without a relevance match. Earlier choices remain readable in version history, and the lead sees at most five as examples, not rules.

A concrete decision may differ, and changes to an approved plan still use Amendments. Archive the current note to withdraw the direction. A direction proposed in Discuss follows normal Project-memory review and replaces this same note when published.

When a Task continues, selection considers its recorded current step alongside the original request. A verification step can bring forward guidance about preparing an authenticated app, even when the original request focused on changing a menu.

Agents are also told when to look beyond the notes they received. They search or ask memory before they start in an area the notes do not cover, before they choose between approaches or change something a person may already have decided, when the prompt says some notes did not fit, and before they ask you about a blocker. Before a blocker question, they check the notes they received and search for relevant saved guidance. They verify any answer against current evidence and act only within their existing authority. If memory is unavailable or leaves a genuine decision unresolved, they can still ask you. A saved note never replaces required approval.

A note with an expiry date stops applying at the start of that UTC day, even before background cleanup records its expired version. Its earlier text remains in history. Older facts and pitfalls rank lower unless newer evidence confirms them. Stable keeps guidance at full strength over time. It does not make the note always-on. Decisions, standards, and preferences remain until corrected, replaced, or explicitly expired.

A Task can also draw on learned guidance for its Project, Goal, routing Team, and workspace. Chat uses the Agent's and workspace's notes, while a lead's heartbeat can draw on the Teams and Goals it currently leads. Access is checked before selection, and each Run records the exact note versions it received.

An Agent can also ask memory a question with tama memory ask. Task Machine searches the notes that apply to the current work, then answers from at most twenty-five of them and cites the exact notes it used. Notes learned from a pattern are marked Inferred and count as weaker evidence than notes someone stated. When notes disagree, the answer names the disagreement instead of hiding it, and when memory does not cover the question, the answer says so. Asking never changes memory. Corrections still go through the editing flows below.

A note can also name where it applies: a tool such as bash, a Connector such as GitHub, a repository, a pattern of files such as lib/billing/**, or the Project, Goal, Team, Agent or workspace the Run works for. When an Agent's tool call touches one of those places, Task Machine shows the matching notes with that call, as context for the Agent to check and not as an instruction. Only notes the Run could already read are shown, and a note arrives at most once per Run, at most three per call. Notes without a place apply wherever they are already supplied. Agents and the compiler set a place when the evidence names one, and an Agent can pass --applies-to when it saves a note.

A note can depend on another note in the same memory, such as a rule that follows from a decision. When the decision is archived, replaced or expires, the note that depended on it reaches Agents marked to verify first, and tidy and learning re-check it against current evidence. Nothing is archived automatically. You do not manage these links. Edit, replace or archive the notes themselves, and the dependent notes follow.

Task Machine also supplies references to relevant Library documents that the Agent is allowed to read. A reference helps the Agent find a document. It does not automatically copy the whole document into every conversation.

Learning from work

Task Machine checks native comments and Human decisions resolved in Inbox for lasting guidance before learning from them. It also checks finished Run transcripts for a failed command, the approach that replaced it, and the check that confirmed the fix, so a debugging lesson can be learned even when nobody wrote it down. A Task's rolling summary is the handoff to the next Run, so it never becomes memory evidence. A comment arrives with its reply context. A decision includes the underlying request and Human response, rather than just its notification. Imported comments, private conversations, and platform, billing, or credential notices do not become memory evidence.

An approved memory question arrives with the Agent's improvement question and your optional context as evidence for learning. Rejection creates no memory evidence, and the compiler can leave memory unchanged when it finds no reusable lesson. Agent memory keeps working habits that apply across projects, rather than progress reports or facts about a single project.

When an Agent leads a Team, a routing recommendation you change or reject in Inbox can teach that Agent too. The Agent learns from what you changed and the routed Task's current context, or your reason for rejecting the recommendation. An unchanged approval with no lesson leaves memory unchanged. Team routing autonomy remains separate from the Agent's memory.

Learning also keeps Project facts, Goal constraints, Team routing agreements, and workspace-wide rules with the scope they belong to. A correction about how you want work done belongs to your member memory, based on who actually wrote or decided it. Changing a Task's reviewer or assignee does not transfer an earlier correction to that person.

Repository and environment lessons belong to the Task's original Project. A correction can teach workspace memory with less evidence of broad applicability when the correction itself is general. General wording around a personal or Project-specific correction does not make it a workspace rule.

Learning happens in the background and does not wait for your approval. Agents save verified working lessons without asking whether to remember them. One correction may leave memory unchanged. Keep complete decisions and evidence on the Task or Team review, since memory preserves useful guidance rather than the full history.

Product requirements stay in their specification or Library document. Memory keeps a discovery that changes how future work should be done, such as using the repository root when a test command cannot find its configuration. Repeating that lesson on another date supports the existing note rather than creating a new one. A decision, approval or status that applied to one Task, ticket or pull request is not memory unless it sets a rule for later work, and then the note records the rule without the Task number, ticket key or pull request number. Notes stay short and general, and an Agent's attempt to save a note that cites a pull request, issue number or UUID is refused with guidance to state the lasting lesson. A learned note cannot invent a blocker or replace a required approval.

Repeated work can also turn a note into a Skill. When a standard or pitfall note keeps being confirmed and the Runs behind it show an ordered procedure that the note alone does not hold, Task Machine proposes a Skill. Autonomy decides whether the proposal waits for your approval, and the note itself stays in memory unchanged.

Each saved change has a version. Automatic changes explain what the Agent learned from its work and why that justified updating its memory.

Select View evidence to see why each note changed. Task, Team routing, Agent suggestion, and earlier-memory cards identify the source. They show the note's exact changes, with added and removed text highlighted, together with its explanation and grouped supporting excerpts. The badge beside the Memory entry label describes what happened to the note, not the Task. Confirmed means new evidence supported the unchanged note. A Team card also shows when you reviewed the routing recommendation.

Select a card's source heading to open the Task, Team, or submitting Agent behind the explanation. Archived Team cards open the Team's Settings page. Agent suggestion cards show when the Agent requested the change, without exposing its private Run context.

These details stay tied to the saved version even when a note or its source changes, or a Task or Team is archived. You only see sources you can currently access. A missing Team review is omitted without deleting its saved audit evidence. Earlier evidence keeps the excerpts and contributions it recorded, without inventing links to individual notes.

Use Version in the page header to choose a saved version and compare what changed. On the Memories heading, two icons switch between the marks and the notes without them. Hover an icon to see its name. In supporting evidence, each changed entry has the same two icons in the corner of its value. Choose the version marked Current or Back to current to return to the current view. Browsing history does not publish or restore it. Older and manually edited versions have no automatic explanation.

Routine work can leave memory unchanged. Reviewing work does not itself prove that a note will improve future results.

Review and edit memory

Open Memories on an Agent, Human, Project, Goal, or Team, or in workspace settings, to inspect its notes and version history. If your role allows you to curate memory, you can add, edit, or clear entries and publish the changes with Publish in the page header, next to Version.

Scroll to reach more notes, including when viewing an older version. Your edits stay unpublished as you browse. If continuing would move those edits out of view, publish them first. Each save changes only the entries you edited, not notes outside your view. If an entry you edited changed after you opened the page, Task Machine rejects the save instead of overwriting that change.

The entry count shows all active notes. There is no limit on how many notes an Agent can remember. Individual entries still have a length limit. Task Machine rejects an oversized change rather than silently dropping guidance.

When you ask an Agent in a comment or Chat to remember something, it can record that a person requested the note. Task Machine keeps that mark only when your comment or Chat started the Run, so an Agent cannot claim a request it was never given.

An Agent with Manage memory can maintain its own memory as it works. It can also change the memory of a Team or Goal it leads, and of a Project it leads under that Project's autonomy policy below. It adds, updates, replaces, archives, and restores single entries, and every applied change keeps its history.

Project and workspace notes follow their own autonomy policy. When review is required, the requested change appears in Inbox. You can edit the note, choose its kind, and change Always on and Stable before approving. For a removal, you can edit the Agent's reason. The Project's current Goal direction must stay a decision and always-on, without an expiry or conditional delivery. A change that would break those rules is refused. Archive it to withdraw it, and withdraw the current direction before restoring an earlier one.

Approval publishes your reviewed change. Rejection keeps current guidance. If the entry changed while the request waited, Task Machine closes the stale request without overwriting the newer note.

Task Machine retains the proposed and reviewed values so corrections count in learned autonomy. Approvals build trust for the selected memory level. Approving workspace guidance does not build Project-memory trust, or the reverse. Trusted requests can publish without individual approval, subject to spot checks and current permissions. Direct publication still needs Manage memory, and direct Project edits must belong to the current Task's Project.

Other requests for Agent, Team and Goal memory become suggestions for background learning. The Agent must still have read access to the target. A suggestion does not change active guidance until the compiler adopts it, and the compiler may leave memory unchanged. Removing Manage memory prevents direct publication. A pending review or suggestion never means the note was saved.

In a note's … menu, curators choose Edit note to change its kind, make it always-on, or set or clear its expiry date, and Replace note to replace it with new guidance. Readers choose View note, which shows the same kind, expiry, always-on and stable settings locked in place, without Save, Replace, or Restore. Remove memory removes a note from your draft. It changes active memory only when you select Publish. Archived, superseded, and expired notes remain inspectable in history and can be restored. A replaced note shows its replacement alongside the original only when you can also read that memory.

You need permission to read Tasks and the Agent, Project, Goal, or Team whose memory you open. Workspace memory requires Task-read access. Changing memory also requires Manage memory, separately from managing the owner's configuration. Ask a workspace owner to grant the access you need.

Tidy cluttered memory

Choose Tidy memory to merge repeated notes and retire the ones that no longer apply. The tidy-up applies as it goes and needs no approval, so you can keep reading and editing while Task Machine works through the notes in the background. Learning from finished work carries on in the meantime, and the Agent's own worker does not need to be running.

When it finishes, a message appears and the page opens the new version next to the one before it, with added and removed wording highlighted just like version history. If nothing needed to change, the message says so and you stay where you are.

Every change keeps its reason in history, and a note a tidy-up retires can be restored. If a note changes while a tidy-up is working on its batch, Task Machine skips that batch and the next tidy-up covers it.

Task Machine also tidies memory on its own. A nightly check tidies memory that has grown a lot since its last tidy-up, and a background review tidies migrated Agent notes that hold obsolete operational state or contradictions. Neither asks for approval or sends a notification.

Move lessons into their owning scope

Choose Organize by scope on an Agent's Memories page to review older guidance against the Projects, Goals, and Teams it recently worked on. The review runs in the background and also classifies existing notes by kind. Original guidance stays active until a shared memory adopts its exact version.

An adopted note becomes superseded. Opening it shows the replacement note when you have access to its shared memory. If the original changed in the meantime, it stays in place. History and evidence show where the guidance came from.

Make a correction last

Explain a correction on the Task or in the Team routing review so the Agent can understand what went wrong and what a good result would look like. If it should guide future work, check that the Agent's memory captures it accurately.

For a rule that several Agents should follow, update their standing instructions, a reusable Skill, or the relevant Library document. Do not assume that one conversation silently updates every Agent's configuration.

Memory does not grant authority

Memory helps an Agent remember useful context. Autonomy controls which permitted actions need review. Editing memory does not grant permissions or promote an Agent to a different autonomy level.