The Four Quadrants of Context: Why Your AI Keeps Guessing

BairesDev’s Justice Erolin offers commentary on the four quadrants of context and why your AI keeps on guessing. This article originally appeared in Insight Jam, an enterprise IT community that enables human conversation on AI.

The question I get in every executive briefing is some version of “which model should we use?” As if the model were the bottleneck.

It isn’t. I have the receipts.

This month I surveyed engineers across our client accounts and asked a simple question: what are you actually doing with AI, and what did it change? I read all responses myself, picked the strongest, and spent this week interviewing those engineers one on one. Different industries: autonomous vehicles, logistics, e-commerce, enterprise SaaS, collectibles. Different tools, different clients, different problems.

The pattern was identical everywhere. Not one standout result came from a better model. Every one came from getting better context to the model. A principal engineer on one of our enterprise accounts put it flat out: model size and quality stopped being the constraint a while ago. The constraint now is the context the AI has, and the tools it can use to go get the context it needs. When context is missing, he said, an agent doesn’t stop. It tries a bunch of things, and if it thinks it succeeded, it hands you something that may or may not actually work.

Once you accept that, a more useful question appears: where does your organization’s context live?

I’ve been thinking about this through an old lens. In 1955, two psychologists built a model called the Johari Window: a two-by-two grid of what you know about yourself against what others know about you. Fifty years later, Donald Rumsfeld accidentally made the same structure famous with “known knowns” and “unknown unknowns.” Risk managers and intelligence analysts have used the quadrants ever since. Nobody, as far as I can tell, has applied them to AI.

So let’s do it. Two axes: what you know, and what the AI receives.

Quadrant 1: You Know it, You Supply it

This is prompt engineering. It’s where we all started, and it’s how a generation of knowledge workers trained themselves to talk to machines. Clear instructions, good examples, paste the relevant code.

Quadrant 1 works. It’s also expensive in a way nobody measures, because the real cost isn’t tokens. Manually supplied context is small and cheap. The cost is your best people spending part of every day hand-feeding the same architecture, the same business rules, the same “here’s how we do things” to a model that forgot it all overnight. Everyone who isn’t your best person feeds it a worse version.

One of our engineers on a logistics account started exactly here, and hit the wall fast. His agent’s context window kept filling up mid-task. Resuming yesterday’s work meant rebuilding yesterday’s context by hand. Switching between tickets meant dragging state between sessions, which he described, correctly, as inefficient for humans and worse for agents.

So he stopped supplying context and built the supply. Today he runs a coordinator agent that spawns specialized workers, each bootstrapped with exactly the documentation it needs. Shared knowledge lives in markdown files he treats like libraries. Workers pull only the files relevant to their feature. Nothing gets retyped.

His throughput went from one ticket every two weeks to twelve to fifteen tickets a month, running four workers in parallel while he supervises.

The operational rule hiding in his story: anything you’ve supplied twice belongs in infrastructure. Repeated Quadrant 1 activity is a signal, and the signal says “automate me.” Notice, though, that his fix wasn’t better prompting. He built pipes. Hold that thought; it’s Quadrant 4, and we’ll get there.

Quadrant 2: You Know it, You Don’t Supply it

This is where AI assumptions happen. You knew the API had a rate limit. You knew that table gets rebuilt nightly. You just didn’t say it, because you can’t hold your whole organization in your head at prompt time. We’re human. We forget things.

Human-in-the-loop review was built for this quadrant, and it genuinely works here, because the reviewer has the missing context. You read the output, you spot the wrong assumption, you correct it.

The interesting evolution is what our best practitioners are doing with the review posture itself. One of our SRE engineers, working inside a client’s incident response function, told me his goal is to be human ON the loop, not human IN the loop. Supervising, not babysitting. His tooling lets him rewind an agent’s context and re-steer with a different prompt rather than argue with a bad conclusion after the fact. Correcting a conversation is expensive. Reverting one is cheap.

Quadrant 2 is annoying but survivable. The next one isn’t.

Quadrant 3: You Don’t Know it, So You Can’t Supply it

The blind spot. And I heard about three flavors of it this week.

The first is lost knowledge. One client we work with has an engineer with over 20 years of tenure, and even he doesn’t know how everything works. There are vast areas of systems the team technically owns where nobody alive knows the behavior. The context exists, technically. It’s compiled into a production binary and scattered across a codebase with hundreds of thousands of lines. No human can supply it because no human has it.

The second is tacit judgment. At an autonomous vehicle client, traffic analysts were spending entire days watching camera footage from the fleet, classifying stop events one at a time. That’s right, that’s wrong, next. The classification logic lived nowhere except in their heads, exercised in real time, never written down. Ask them to document it, and you’d get a fraction of what they actually know.

The third is structural. At a global e-commerce marketplace, one of our tech leads works in a product domain spanning 15 interrelated projects: messaging, events, GraphQL, REST APIs, integrations internal and external, all connected to the same core. Each project was documented individually. The correlations between them were documented nowhere. An AI agent could handle any single project fine and still get the system wrong, because the knowledge of how the pieces relate lived only in the heads of the most senior engineers.

Here’s what makes this quadrant dangerous: human review fails by definition. The reviewer is missing the same context the AI is missing. You cannot catch an error you don’t know is an error. When an AI makes a Quadrant 3 mistake, it sails through your approval process wearing a confident face.

Most AI governance conversations obsess over reviewing AI output. Almost nobody talks about auditing AI input. Quadrant 3 is why they should.

Quadrant 4: You Don’t Know it, But the AI Gets it Anyway

This sounds like a paradox. It’s actually the whole point of context infrastructure: context flowing to the AI without passing through a human’s head first.

All three Quadrant 3 stories got solved this way, and the three solutions form a ladder.

At the individual scale, you’ve already met the logistics engineer and his coordinator-worker fleet.

At the account scale, the legacy systems client stood up a centralized gateway connecting agents, read-only, to production data and their log aggregator. Incident troubleshooting that used to take an hour of hypothesis-and-check dropped to about five minutes, because the agent pulls real performance metrics and runs intelligent log queries against systems no individual fully understands. In one recent incident, our engineer’s agent found the root cause in roughly five minutes while the client’s on-call responder had already been digging for half an hour. The autonomous vehicle client reached the same quadrant by a different route. Instead of asking analysts to document their judgment, the team pointed AI at years of historical classifications the analysts had already made. The tacit knowledge was machine-readable all along; it just lived in labeled outcomes rather than in documentation. The resulting classifier now runs daily, the entire analyst team depends on it, and the org saves 15 to 30 hours per week. Payback took under eight weeks. When the engineer paused the pipeline for a day of testing, thirteen emails arrived asking where their output went. He’d assumed nobody was using it yet.

That’s what Quadrant 4 adoption looks like. Not a rollout announcement. Thirteen worried emails.

At the organizational scale, the e-commerce tech lead built what he calls an organization context: a versioned repository that any engineer can clone, wired into every project with a single standing instruction telling the agent to load the organization context alongside the project context. The design detail worth stealing is that it holds pointers rather than copies. Each project keeps its own context; the organization layer maps what each project is, what it’s responsible for, and how it relates to the others, then routes the agent to the right place. The cross-project correlations that used to live in senior engineers’ heads now live in a repo. A new project gets added, the map gets a new entry, and every agent in the domain understands the new dependency.

And he answered the question every executive should ask next: how does this stay current? His team treats the context layer like code. Change the infrastructure, update the organization context, same commit discipline. He’s working on automating the refresh, but the norm came first, and the norm is the hard part. Context isn’t a document you write once. It’s an artifact you maintain.

Missing Context isn’t Free

Now the budget conversation, because the economics of this get inverted in most boardrooms.

The legacy-systems engagement measured it directly: supplying context up front, instead of letting agents hunt for it, cut token costs roughly 70 percent. The hunt is the expense. Every time an agent burns tokens guessing at what nobody gave it, you’re paying compute for the privilege of missing infrastructure.

Our sharpest practitioners already treat context like a budget. The SRE engineer pushes deterministic work out of the model entirely, building small extensions so the agent handles routine operations programmatically instead of reasoning through them. His discipline: the fewer tokens a session burns, the better the session, because bloated context makes agents drift. Running that way, he executed a fleet rollout across 200 production clusters in a single day, under 150,000 tokens, alone. The same class of rollout previously took three people a week.

Context infrastructure didn’t add cost on these engagements. It removed the cost of guessing.

The Grid is Also a Timeline

Look at the quadrants again and you’ll notice they’re a chronology. 2023 was the Quadrant 1 era: prompt engineering courses, “10 prompts that will change your life.” 2024 was the Quadrant 2 era: copilots everywhere, humans reviewing everything, adoption without much architecture. The organizations pulling ahead right now are building Quadrant 4: gateways, connectors, context layers, governance on what their agents can know.

Quadrant 3 never fully goes away. But we’ve solved this class of problem before. Twenty years ago you couldn’t enumerate your production failure modes either, so you didn’t try. You built observability instead. Logs, metrics, traces, so the unknown became inspectable the moment it mattered. Nobody reads logs all day; the logs are there for the moment you need them. A pointer-based context layer works the same way. It doesn’t preload everything into every agent. It knows where everything lives, and the agent reaches for it when the task demands.

If your company already bought the observability argument, you’ve already bought this one. You just haven’t applied it to AI yet.

Where Does Your Context Live?

So here’s the diagnostic. Set the model debate aside for a quarter and map your AI activity to the grid.

Heavy daily Quadrant 1 activity means your experts are doing infrastructure’s job by hand. Frequent Quadrant 2 errors mean your workflows capture less context than your people carry. A large Quadrant 3 surface, and the tells are legacy systems, the one long-tenured person everyone routes questions through, and project teams that only understand their own project, means you hold risk that no amount of output review will catch. And your Quadrant 4 footprint is, bluntly, your actual AI maturity. Not how many licenses you bought. How much of your organization’s knowledge can reach a model without a human retyping it, and whether that knowledge is versioned and maintained like the asset it is.

The model wars will keep producing headlines. The durable advantage is quieter: context position. Two companies with identical models and identical headcount will get wildly different results, and the difference will be which one made its institutional knowledge machine-reachable first.

Your context is already somewhere. The only question is whether your AI can get to it.