Context Engineering: From Amnesia to Expertise

There's a moment in The Matrix when Neo opens his eyes and says: "I know kung fu."

Ten seconds earlier, he knew nothing. Then Trinity loaded the right context—martial arts training programs, combat patterns, years of simulated experience—directly into his brain. The model didn't change. The context did.

This is the promise of context engineering. Not memory management. Not token optimization. The systematic loading of expertise that transforms a generic LLM into a domain master.

The Real Problem

Most teams treat context as a technical constraint. How do we fit more tokens? How do we avoid the "Lost in the Middle" problem? How do we manage retrieval latency?

These questions matter. But they miss the point.

The real question is: what context would make this agent exceptional?

A generic agent can look up vacation policies. An expert agent knows that Sarah in Engineering always asks about PTO before big releases, that your company interprets "unlimited PTO" conservatively, and that the last three people who asked this question were actually signaling burnout.

That's not retrieval. That's judgment. And judgment comes from the right context.

Three Layers of Context

Internal context is the easiest to acquire. Connect to your knowledge base, ingest your documentation, index your codebase. Most RAG systems stop here.

External context requires active research. Who are your competitors? What regulations apply? What do your customers actually care about? This is the context that prevents agents from giving technically correct but strategically wrong answers.

Institutional knowledge is the hardest and most valuable. It's the unwritten rules, the implicit preferences, the "that's not how we do things" corrections that take humans months to absorb. It's why the second agent shows up smarter than the first—a huge portion of this context is shareable.

Context as Voice

Generic agents sound generic. They use corporate filler, hedge everything, produce the same beige prose as every other LLM output.

The difference isn't the model. It's the context.

When an agent has absorbed your best writing—your marketing copy, your closed-deal emails, your leadership communications—it develops voice. Not through fine-tuning (expensive, fragile, loses general capability) but through in-context learning. The model sees how YOU communicate and adapts.

This is why context curation matters more than context volume. Ten examples of your best work teach more than a thousand examples of mediocre output. The agent learns what "good" looks like from what you show it.

Context as Eval Fuel

Here's the connection most teams miss: context quality directly determines eval performance.

An agent evaluated against generic benchmarks produces generic results. An agent evaluated against your standards—with your edge cases, your quality bar, your domain-specific failure modes—produces exceptional results.

Building Agent Evals covers the methodology. The insight here is simpler: the same context that makes an agent smarter also makes your evals meaningful. Your internal documents define what "correct" looks like. Your historical decisions define what "good judgment" means. Your experts' feedback defines where the bar sits.

World-class agents aren't trained differently. They're evaluated differently, against context that captures what actually matters.

The Accumulation Effect

Traditional hires start from zero. Every new person re-learns your industry, your competitors, your internal processes. Months of ramp time before they're productive.

Agents inherit accumulated context.

The first agent you deploy learns your business the hard way—through corrections, failures, and explicit feedback. But that learning persists. The second agent arrives pre-loaded with everything the first one learned. The third agent benefits from both.

This is the compounding advantage of context engineering. Each agent adds to the institutional knowledge base. Each correction improves the next generation. The more you invest in context, the faster every subsequent agent onboards.

The Technical Reality

None of this negates the technical constraints. Context windows are finite. Retrieval can fail. Token costs accumulate.

The patterns that work:

Dynamic loading: Don't pay 55,000 tokens for tool definitions you won't use. Load context on demand based on the task at hand. The MCP Tax documents why this matters.

Tiered memory: Not everything belongs in active context. Working memory (0-32K) for active reasoning. Episodic memory for session coherence. Long-term storage for retrieval when relevant. Agent Memory Architecture covers the implementation.

Retrieval discipline: Wrong context is worse than no context. Hybrid search, re-ranking, quality thresholds. RAG Reality Check has the playbook.

Context hygiene: Prune intermediate results. Summarize old history. Don't use the model as a data transport layer—let code handle bulk operations while the model orchestrates.

But these are implementation details. They serve the larger goal: getting the right context to the agent so it can exercise real judgment.

The "I Know Kung Fu" Moment

You'll know when context engineering is working. The agent stops asking clarifying questions you've already answered. It anticipates edge cases. It sounds like someone who actually understands your business.

It's not magic. It's not AGI. It's the systematic accumulation of the context that converts generic capability into domain expertise.

The trajectory isn't model upgrades. It's context accumulation. The agent that works with you for six months, absorbing feedback, ingesting new information, learning your preferences—that agent becomes something qualitatively different from a fresh deployment.

Not because the weights changed. Because the context did.

The Bottom Line

Context engineering is the discipline that transforms LLMs from generic tools into genuine expertise.

The technical layer matters—context window management, memory architecture, retrieval pipelines. But the strategic layer matters more: what context would make this agent exceptional? What does it need to know to exercise real judgment? How do you accumulate institutional knowledge over time?

Get the context right, and everything else follows. The agent develops voice. It passes meaningful evals. It compounds its expertise with every interaction.

That's the "I know kung fu" moment. Not a model breakthrough. Just the right context, loaded at the right time.

See our platform architecture for how we implement context accumulation, and our eval framework for how we measure the results.