If 2025 was the year of agents, 2026 is the year of context. In April, Sam Altman named the biggest limitation of today's AI as a lack of user context: every session starts from zero, users repeat themselves, and the system never builds a continuous understanding of who they are and how they work. The models are good enough. What they're missing is what we know.
So how do we actually give agents context today? Two ways, mostly.
Skills - a set of instructions, scripts, and resources the agent loads when a task matches. Very customizable, very personal. And completely static.
MCP - the Model Context Protocol, which lets the agent call live systems. Real-time and fresh. But generic: an MCP server returns what the API returns, not what this task, for this user, actually needs.
One is tailored but frozen. The other is fresh but not tailored. This post is about the layer missing in between - and why I think the static skill, as we write it today, is a cache with no invalidation.
A skill is a printed map
Open any real skill in your repo and look at what it teaches the agent. It teaches it how to navigate by hard-coding:
- Files and links - folder names, file names, URLs.
- Database schema - SQL schemas, tables, columns.
- Teams and channels - the relevant people, the Slack channel to announce in.
- APIs and infrastructure - endpoints, service names, ports, account IDs.
- Feature flags - the exact flag name to flip.
- Scripts and tooling - the CLI command that does the thing.
A skill is a printed map. It was accurate on the day someone wrote it. Then a table gets renamed, a channel gets archived, the on-call rotation changes owners, and the flag gets cleaned up. The map doesn't know.
As engineers we already have a name for this pattern: it's magic numbers sprayed all over your code. We spent decades learning not to do it in software, and then we started doing it in the instructions we hand to our agents. Maybe it mostly works for now - but most skills are barely a year old. The drift hasn't had time to show up yet. It will, and it will look exactly like stale context: confident, plausible, wrong.
The context explosion nobody measures
Staleness is the slow problem. The fast one is waste.
Here's a homework assignment. Next time an agent finishes a task you gave it, run this prompt in the same session:
"Analyze the skill files you've used for this task - based on the lines you really needed vs. the lines you read into context - calculate the precision of context loading in this session."
The results we keep seeing are not subtle. Median precision is under 1%. Even at the 90th percentile it's under 10%. The agent read hundreds of lines about every service, every edge case, and every runbook branch to use the three lines that applied to this task.
That isn't just a token bill. Irrelevant context competes for the model's attention; it's the context overload failure mode wearing a different hat. And the natural fix - write more skills, more specific skills - makes both problems worse: more facts to drift, more files to over-load.
From static to dynamic skills
Put the two problems side by side and the shape of the fix is obvious. A static skill is a cache: someone computed "what you need to know to do X" once, wrote it to disk, and every agent reads that snapshot forever. Caches are fine - as long as you can invalidate them and as long as you only read the entry you need. Static skills do neither.
The alternative is to compute the skill instead of caching it. The agent stops reading a file and starts asking a question, over MCP:
"What do I need to know about doing <the user's task>?"
And a context engine answers with exactly what's needed for that task - no more, no less, current as of now. To build that engine, three steps.
Step 1: Separate the how from the what
Every skill mixes two very different kinds of content.
How to do the work. The stable process - the way your organization does a deploy, a review, an incident, an analysis. This changes rarely, it encodes judgment, and humans should write it. No drifting facts here.
The facts you need to know. Every URL, name, ID, and entity we listed above. This changes constantly, nobody remembers to update it, and an automation should keep it in sync - not a person.
The trick is how you link them: by meaning, not by value. Instead of writing 65464123 in the skill, write <Production AWS account ID>. Instead of #payments-oncall, write <On-call channel>. The process now describes what it needs without pretending to know the current answer. It's the same refactor as replacing a magic number with a named constant - except the constant is resolved at runtime, from the real world.
Step 2: Index and map it offline
For the placeholders to resolve, something has to know the answers. That's the expensive part, and it should happen offline, ahead of any question.
Collect from the source of truth. Pull facts from where they actually live - cloud accounts, Slack, Git, databases, feature flags, docs - not from what someone wrote down once.
Map entities by meaning. Not text chunks; things and how they relate. payments-service runs in a specific production AWS account, writes to the payments database, is guarded by a kill-switch flag, and pages #payments-oncall. That graph is what lets "the on-call channel" mean something specific when the task is about payments.
Every fact carries metadata. Where it came from, when it was last verified, who owns it, and who may see it. The map is re-synced continuously: when a value changes, the map changes - and no skill needs editing.
This is most of the work of a context layer, and it's deliberately front-loaded. The expensive work happens offline, so the query can be fast.
Step 3: Compose a just-in-time skill at query time
Now the agent asks: "What do I need to know to deploy a hotfix to payments-service?" - on behalf of a specific user, with that user's permissions.
The engine takes the stable deploy process:
- Deploy to
<Prod AWS account> - Announce in
<On-call channel> - If errors spike, flip
<Kill-switch flag>
It resolves only the facts that process references, for the entity the question is about, filtered to what this user is allowed to see:
- Deploy to
65464123 - Announce in
#payments-oncall - If errors spike, flip
payments_v2_killswitch
That's a just-in-time skill. Precise, because it contains only what this task references. Fresh, because every value was resolved from the map a moment ago. Scoped, because it was composed for one user's permissions. And disposable: it's discarded after the task, so there is nothing to go stale.
Static skills are caches. Just-in-time skills are computed.
How this looks in practice
This isn't hypothetical for us; it's the shape of the system we run at modus. Connectors continuously mine context from the tools a company already uses into context items - each with its source, its place in the hierarchy, and an access list inherited from the source system. When an agent calls Modus over MCP, it sends its intent, not a file name. The composer selects and assembles only the items that intent needs, and reports how many it kept out of everything in scope - the precision number from the homework, measured on every call instead of guessed.
Permissions are checked fresh on every read, not cached from the last call. That matters more than it sounds: the same permission drift that makes a company brain dangerous makes a static skill dangerous too. A file on disk can't know who is reading it. A composed answer can.
The skills you write don't go away. They get smaller and more durable - the part that encodes how your organization works, with named sockets where the facts used to be. The protocol moves the bytes; the composition layer decides which bytes are worth moving.
Takeaways
- Skills hard-code facts, and facts drift. Every name, ID, and URL in a skill is a magic number waiting to go stale.
- Agents use under 1% of the skill context they load. Measure it in your own sessions; the number is rarely flattering.
- The process is stable, the facts aren't. Store them apart. Humans write the how; automation keeps the what in sync; link them by meaning.
- Static skills are caches. Just-in-time skills are computed. Index offline, compose per task, per user, and throw it away after.
This is what modus builds.
A context warehouse for AI agents - facts mined from the source of truth, composed just in time for every task, permission-checked on every call.