TabMate

Internal state

Internal state is TabMate’s running notebook for your workspace. It is not a memory you manually save. It is a system-managed layer TabMate updates on its own so it can stay aligned while your work evolves across tabs and turns.

If memories are what TabMate can recall by relevance, and pins are what TabMate always includes, internal state is how TabMate keeps track of the work in motion.

What Internal State stores

Internal state is split into two scopes.

1) Conversation overlay (“Right now”)

This is short-lived state for the current conversation. It captures things like:

  1. Current goal
  2. Goal stage
  3. Next likely steps
  4. Current constraints
  5. Short-term instructions
  6. Open threads
  7. Recent milestones
  8. Working assumptions

This is the part that helps TabMate not lose your near-term direction in long threads.

This scope is explicitly volatile and conversation-tied.

2) Workspace profile (“Workspace patterns”)

This is slower-moving state for the workspace overall. It captures patterns like:

  1. Stable preferences
  2. Stable dislikes
  3. Stable working style
  4. Decision patterns
  5. Recent shift signals

This is the part that helps TabMate carry your repeated ways of working across conversations in the same workspace.

This scope is slower-moving and shared across conversations inside a workspace.

Lifecycle and expiry behavior

Internal state has different lifecycle rules per scope:

  1. Conversation overlay has a time-to-live (TTL). Default overlay TTL is 7 days.
  2. Workspace profile does not use overlay TTL and persists as workspace-level state.

Conversation overlay can also be considered stale if newer user turns exist beyond its source cursor, and stale overlays can be reset/cleaned by maintenance paths.

How Internal State gets generated

Internal state updates after asks as part of TabMate’s post-response processing. TabMate reviews:

  1. Recent transcript
  2. Existing internal state
  3. Current workspace context
  4. Relevant compressed history (when needed)

Then it updates only bounded fields, with explicit actions for volatile fields (keep, replace, or clear). In simple terms: if your goal changed, the old goal can be replaced or cleared instead of silently hanging around.

💡 Internal state is confidence-scored and token-budgeted. Prompt rendering picks the first variant that fits budget while preserving core fields.

Confidence and prompt budgeting

Internal state slots include confidence and trust level metadata. When TabMate renders Internal State into prompt context, it applies confidence filtering and bounded list limits.

Examples of rendered constraints include:

  1. Minimum confidence threshold for inclusion.
  2. Limited counts for constraints, instructions, open threads, assumptions, and profile fields.
  3. Variant fallback logic to fit token budget without dropping critical context first.

This keeps state useful without overpowering page evidence and current user instructions.

Decay behavior

Low-confidence slots can decay over time.

  1. Slots above a confidence threshold are retained.
  2. Lower-confidence slots can lose confidence after a decay window.
  3. Very low confidence slots can be dropped.

When the current goal changes, related fields such as goal stage and likely steps may be cleared or pruned, which prevents stale short-term intent from lingering.

Why this helps

Without internal state, long workflows drift. With it, TabMate can:

  1. Keep active goals and constraints visible while you switch tabs
  2. Carry unfinished threads forward without you repeating everything
  3. Preserve stable working preferences separately from one-off details
  4. Recover faster after long or complex conversations

This is also one of the reasons memory candidates get better over time: TabMate has a clearer picture of what is actually important versus what was just temporary.

What control you have

Internal state is mostly automatic, but you still influence it heavily.

Direct control today

  1. You can open Notebook to view what TabMate is currently tracking.
  2. You can refresh Notebook to pull the latest state snapshot.

Indirect control (most important)

  1. Be explicit about goal changes (“we are now doing X”)
  2. State constraints clearly (deadlines, scope limits, must/avoid rules)
  3. Repeat durable preferences when they matter
  4. Correct wrong assumptions immediately

TabMate uses this signal to update or clear internal state fields.

Reset/clear behavior

You cannot edit Internal State line by line.

If you want TabMate to stop carrying old context, start a new conversation or clear old workspace history. As you keep working, TabMate also updates this state automatically based on what you tell it.

So in practice: you guide Internal State by giving clear instructions, correcting wrong assumptions, and managing which conversations/workspaces you keep.

Internal State vs Memories vs Pins

Use this separation model:

  1. Internal State: system-managed steering context.
  2. Memories: user-approved durable knowledge.
  3. Pins: user-controlled temporary always-on context.

They are complementary, not interchangeable. If you need guaranteed persistence and explicit control, save memory. If you need immediate turn-by-turn emphasis, pin. If you need automatic continuity across long threads, rely on Internal State.