Skip to main content
A worker only knows what’s currently in its context — the instructions, files, and conversation it can “see” in a given turn. CogniAgent assembles that context automatically, compacts it when a task runs long, and layers in memory so a worker doesn’t lose the thread or repeat work it already finished.

​
What’s in a worker’s context

Every turn, a worker’s context is assembled from a few layers, from most stable to most specific. The stable layers — identity, instructions, and the skills index — are the same across all of a worker’s tasks; the volatile ones — files, conversation, and the task’s goal — change task to task.
Who the worker is and how it should operate: its persona, plus the rules and conventions you gave it when you set it up. This is the closest thing a worker has to a job description, and it’s present in every task the worker runs.
A lightweight index of the worker’s skills — just names and short descriptions. A skill’s full instructions load on demand only when the worker actually decides to use it, so having many skills doesn’t bloat every turn’s context.
The documents and code the worker is working with in its sandbox for this task, read as needed rather than loaded all at once.
The back-and-forth for this task: what you asked, what the worker did, and what it found — the part of context that grows the fastest, and the part compaction manages.
The goal for this specific task, kept close at hand so the worker doesn’t drift from what you actually asked for.
This layering is also what the agentic loop reads from at every plan, act, and observe step — the stable layers give the worker its identity and capabilities, the volatile ones tell it what’s happening right now. The stable and volatile layers also differ in who sees them. Identity, instructions, and skills live on the worker, so they’re shared by every task that worker runs. Conversation history, files, and the task’s goal are private to the task and visible only to the person who started it.
A worker’s context is assembled once when a task starts and carried forward from there. If you edit a worker’s instructions or skills while a task is already running, the change won’t reach that task mid-flight — it takes effect the next time you start a new task with that worker. Hooks are the one deliberate exception: they’re re-read live at the start of every turn, so fixing a broken hook takes effect on the very next turn of an already-running task.

​
Automatic compaction keeps long tasks running

A model can only hold so much conversation in context at once. As a task’s conversation grows, CogniAgent watches how much room it’s using and, before it runs out, automatically compacts: it folds the older parts of the conversation into a structured checkpoint summary, while your most recent turns are kept exactly as they happened. The checkpoint carries forward what matters most from the folded turns — the goal, decisions made, key facts and values, files touched, and what’s still outstanding — so nothing important gets silently dropped. You don’t have to do anything to trigger this; it happens automatically as part of running the task, and the worker keeps going without you needing to re-explain where things stand.

​
The checkpoint is reference-only

A compacted checkpoint is background, not a new to-do list. The worker treats it as a summary of what already happened — not as work still waiting to be done. That distinction matters: without it, a worker could misread its own summary as an outstanding request and redo steps it already completed, for example re-creating a file or re-running a step that the checkpoint says is already done. A task can be compacted more than once over its lifetime. Each new checkpoint absorbs the previous one along with whatever’s been folded in since, so the worker is always working from one current summary plus its most recent turns — never a stack of old, conflicting checkpoints to reconcile.

​
Memory that grows with the worker

Context inside a single task is temporary — it’s scoped to that conversation. Memory is what a worker can carry forward between tasks. CogniAgent structures this in tiers:
What’s on the roadmap is a worker fully forming and refining this memory on its own, without you writing or approving anything. See self-improvement & learning for the full picture of what ships today versus what’s ahead.

​
Why this matters

Together, layered context and automatic compaction are what let a worker stay on a long, multi-step task without you babysitting it. You don’t need to keep the conversation short, re-paste earlier decisions, or restart when things get long — the worker keeps the thread itself, checkpoint after checkpoint, until the task is done.

​
Next steps

The agentic loop

See how context feeds each plan, act, and observe step.

Skills

Package reusable know-how a worker loads on demand.

Execution, sandbox & files

Where the files a worker works with actually live.

Self-improvement & learning

How memory notes and skills are proposed, reviewed, and approved today.