# After the context pyramid

> Context engineering stacks what an agent reads, from the stable to the fleeting. IllAIra puts the same layers in a file the person owns, across conversations and models — in one suite made for people, not for developers.

designed version: https://illaira.com/deep-dives/context-pyramid · index: https://illaira.com/llms.txt

---

[Skip to content](#content)

[← Deep dives](https://illaira.com/deep-dives.md)

Deep dive

Context engineering taught whoever builds agents to stack what the model reads, from what never changes to what lasts a single turn. IllAIra takes the same pyramid and hands it to the person on the other side of the chat: in a file they own, which stays from one conversation to the next and from one model to another.

The objection

## “I already do context engineering: my context has its pyramid.”

Good: then you already know the layers IllAIra is made of. Identity at the base, then what it knows, then where things stand, and the request at the tip. **We did not invent a different shape.**

What changes is who holds it. In a context pyramid the layers belong to whoever builds the agent; in IllAIra they belong to whoever talks to the model, and they travel with that person. This page says what the pyramid is, where the two meet, and what each one does better.

## What the context pyramid is

Context engineering is the craft of choosing what ends up in front of the model at every step. Andrej Karpathy summed it up in June 2025 as «filling the context window with just the right information for the next step». The pyramid is its most common picture: **the stable at the base, the fleeting at the top**, and each layer refreshed at its own pace.

There is more than one version. In Neo4j’s guide (Michael Hunger, December 2025) the layers are three: a persistent base with the system prompt, the safety rules and the canonical facts; a dynamic layer with examples, recent memory and metadata, rotated task by task; an ephemeral layer with the user’s question and the tools’ output, kept small. In Karo Zieminski’s framework for product managers (Product with Attitude, May 2026) the layers are four — Identity, Knowledge, State, Task — each with its own rhythm, from «rarely» to «per task», and someone in charge of touching it.

It works, and it is worth learning. A base that stays still can be cached, and that cuts tokens and cost; separate layers let a failure be traced to the one that broke. Nothing on this page takes that away.

## The same layers, in a file

Put the four layers next to the pieces of IllAIra and the shape is the same. What changes is the column: on one side a system that someone builds, on the other a file that someone owns.

| Layer | In an agent someone builds | In IllAIra |
| --- | --- | --- |
| Identity — who it is, and its rules | The system prompt, written by the developer and invisible to whoever chats. | The Reminder: who the model is for you, its ground rules, and the zones that say what may be rewritten and what may not. You read it, you change it. |
| Knowledge — what it knows | Documents in a vector store or a graph database, retrieved by a pipeline (RAG). | Memory modules in the same file. Search by meaning and the knowledge graph run on your device, and the Sphere Grid shows you what is in there. |
| State — where things stand | A scratchpad for the task, and summaries that a model writes into the store on its own. | Journals: the model drafts the entry with the Logger, and you decide with one tap on the MemoKen whether it stays. What is kept is text you can reread. |
| Task — what is asked now | The user’s message and the tools’ output, short-lived. | Your message, and your files when you want them. |

The only layer that starts from zero is the one that should: the request. The other three are already there when the conversation opens — in any engine that reads the file.

## The difference is who holds the pyramid

A context pyramid is a design choice of whoever builds the agent: they decide what goes into the base, where the memory lives, what gets dropped. It can last — the base is cached, the memory sits in a store — but it lasts **inside their system**. The person chatting sees the answers, not the layers.

IllAIra moves the same layers to the person. The base is a page they can open; what climbs from the conversation into the memory passes under their eyes; and when they change model, the pyramid leaves with them, because it is a file and not a row in someone else’s database.

This is the sense in which we call it the next step: **not a new idea about context, but a new owner for it**. Context engineering was written for those who build; here the same discipline is delivered to those who use.

## From a method to a suite

Whoever builds a serious context today assembles a stack: a system prompt, a memory store, a vector index, a graph, a notes app, an export tool to get the data out of the providers, a viewer to see what is inside. Every piece is good, and every piece has its own account, its own key, its own documentation — and the whole assumes you write code.

IllAIra puts those pieces in one place, for people who do not write code:

- **Identity**: the Reminder, from the free Loom to the full configurations, with the zones the app enforces.
- **Memory**: modules and journals, with the Logger that writes and the MemoKen that keeps.
- **Search by meaning**: the index of your files, built on your device with a model you download once.
- **Knowledge graph and Sphere Grid**: the entities and links inside your files, and the structure of the profile drawn as it is declared.
- **Out of the providers**: the Toolkit and the migration guide turn chats, memories and custom instructions into Reminder, modules and journals, and your export never leaves the device.
- **Any engine**: the providers’ models with your file, a model running on your computer, or your own key.
- **Modules**: the Bazar, where capabilities are added one module at a time.

The same suite on the Android App, in the WebApp and on the desktop for Windows and Linux. **The apps are free with an account**, and so are the Loom and Tier 2; no paid plan with any provider is needed. The larger Reminders, Tiers 3 to 5, are on Patreon.

## What the pyramid does better

Scale, first of all. A pyramid built into a product serves thousands of users from the same base, retrieves facts with measured accuracy, and refreshes everything on its own. The developer controls every token, and a cached base costs less than a file read again at every conversation.

IllAIra has its prices, and they belong here: the file costs tokens every time it is read; the format is something to learn; what stays is a yes or a no that nobody says in your place; inside the model the zones are text, and only the app enforces them. And a model running on your computer is smaller than the largest ones in the cloud.

The two do not exclude each other. Whoever builds an agent with a pyramid of their own can use an IllAIra file as its identity layer: the Standard is published for exactly that.

## In one line

The context pyramid tells you how to arrange what the model reads. IllAIra gives you that arrangement as something you own, and keeps it from one conversation to the next, and from one model to the next.

Sources, read on 15 October 2026: Neo4j, «What is context engineering in AI agents? A practical guide» (Michael Hunger, 19 December 2025); Karo Zieminski, «The Context Pyramid: A PM’s Framework for AI Agent Context Engineering» (Product with Attitude, 1 May 2026 — the full article is for subscribers, and we cite only its public part).

[Open the WebApp](https://illaira.com/webapp) · [Compared with the other roads](https://illaira.com/understand.md#comparison) · [Read the Standard](https://illaira.com/standard.md)