Frequently Asked Questions About Unblocked Context Engine Framework
21 answers covering everything from basics to advanced usage.
// Basics
What does 'access is not understanding' actually mean?
It means connecting an agent to data via MCPs or pipes only lets it retrieve data — it doesn't teach it how to interpret that data or know your patterns. An agent with access but no context is like a day-one engineer who doesn't know what they don't know; it writes code from scratch without realizing a shared service already exists.
What is satisfaction of search and why does it break agents?
Satisfaction of search is a phenomenon from radiology where a searcher stops looking after finding the first plausible answer, missing other critical findings. In agents, it means they stop retrieving context at the first relevant result, missing the correct architectural pattern or an existing service. This produces code that compiles but breaks the system in production.
What inputs do I need to build a context engine?
You need three required inputs: your code repository (to build the social graph and extract patterns), your corporate knowledge corpus (docs, Slack/Teams, tickets, SaaS tools, runbooks), and the specific agent task or query. Optionally, engineer identity personalizes retrieval via the social graph, and data governance rules enforce permissions — especially important at 20+ team members.
What is a token-optimized research packet?
It's the compressed, precisely targeted context output the engine delivers to an agent before execution — containing only what the agent needs: architectural patterns in use, existing relevant services, who owns what, and known constraints. It's not a raw data dump. Delivering it up front dramatically improves all downstream choices and actions while saving tokens.
// How To
How do I build a social graph of my engineering organization?
Use commit history and PR review data to map who authors what, who reviews whom, and which engineers own which services. Node size can represent commit volume; edges represent review and collaboration relationships. Open-source tooling can generate this graph procedurally by pointing at a git repo. The engine then uses it as a pivot point to scope retrieval.
How do I implement exhaustive retrieval instead of naive RAG?
Build retrieval that constructs a structured query from the agent's task, traverses all relevant data surfaces exhaustively, applies the social graph to scope results to the right context, and surfaces conflicts rather than silently picking one source. Avoid dropping data in a store and letting the agent crawl it — that triggers satisfaction of search and first-hit-wins failures.
How do I run an agent in Plan, Execute, Review mode?
In Phase 1 (Planning), the agent calls the context engine to build a correct, org-aware implementation plan. In Phase 2 (Execution), it executes the plan and can re-call the engine mid-task for clarification. In Phase 3 (Code Review), the agent or a human calls the engine to review output against organizational patterns. The engine is most valuable at planning and review.
How do I resolve conflicts between contradictory data sources?
When retrieved data contains contradictions — like code in main versus a Slack message from the CTO — use social graph authority signals (seniority, role) and recency to determine ground truth. Pass both the resolution and the sources to the agent so it understands why. A CTO statement in a thread outweighs an incorrect implementation in main.
How do I ingest data sources without violating permissions?
Apply your data governance rules at ingestion time to respect permissions — define which data is private and which roles can see what. This matters especially at 20+ team members. Ingest both static sources (docs, CLAUDE.md, runbooks, ADRs) and runtime sources (Slack/Teams, PRs, tickets, SaaS data) into a unified corpus, but enforce the permissions model throughout.
// Troubleshooting
My agent writes code that compiles but breaks in production — what's wrong?
Your agent likely has data access but no organizational understanding, and is falling victim to satisfaction of search — stopping at the first plausible hit. It writes bespoke implementations while missing existing shared services and patterns like your factory pattern. Build a context engine that retrieves exhaustively and delivers the correct patterns before the agent plans.
My agents keep getting stuck in doom loops of correction — how do I fix it?
Doom loops happen when you're the context engine, manually re-feeding context every session. Climb the Context Ladder to a dynamic context engine that delivers a token-optimized packet up front during the planning phase. High-quality planning context is the primary lever on output quality, so front-loading it eliminates the back-and-forth correction cycle.
Why is my agent ignoring the correct pattern even with MCP access?
Because access is not understanding. MCP access lets the agent retrieve data but not interpret it or know your conventions. It also stops at the first plausible result due to satisfaction of search. You need exhaustive targeted retrieval plus a social graph to surface and scope the correct pattern, not just a pipe to the data.
My cached answers are giving agents wrong information — why?
Because caching context answers is equivalent to writing docs — they go stale the moment they're written. A cached answer to the same question 24 hours later may be incorrect because the system changed. Stop caching and serve fresh context every time, accepting the latency cost, since stale context leads to unpredictable and sometimes catastrophic outputs.
// Comparisons
How does a context engine compare to just using CLAUDE.md files?
CLAUDE.md is the curated context layer — the second rung of the Context Ladder. It's better than manual feeding but goes stale immediately, lacks runtime signals like recent PRs and Slack decisions, and requires human maintenance. A context engine is dynamic and runtime-aware, personalizing retrieval per requester and always reflecting current reality without a human curator.
How does a context engine compare to a larger context window?
A larger context window is a substitute for reasoning only in theory. Even a 1-million-token window can't reason over unstructured dumps — it needs entities, relationships, and targeted retrieval. A context engine reasons across surfaces and compresses to a small, precise packet. The small well-reasoned packet outperforms the large noisy window on both quality and token cost.
How does the social graph differ from an org chart?
An org chart shows reporting hierarchy; a social graph shows real working relationships derived from commit and PR history — who authors which services, who reviews whom, who's the domain expert for what. The engine uses this graph as a pivot point to personalize retrieval and to inform truthiness during conflict resolution, which a static org chart can't do.
// Advanced
Should I build the context engine only for coding agents?
No — the same engine that serves background agents also delivers leverage in human-facing surfaces. Expose it in ask-engineering Slack channels (auto-detect questions, score confidence, respond), ticket enrichment and triage, and incident management. One engine serving all surfaces multiplies your leverage; building it only for agents wastes the investment.
What is the expert graph and how does it differ from the social graph?
The expert graph is a component of the social graph that maps which engineers are the domain experts for which services, libraries, or areas of the codebase. It's used to route queries to the right people and to inform code review. The broader social graph also captures authorship, review, and collaboration edges used for personalization and conflict resolution.
How do I expose the context engine to a coding agent harness?
Surface the engine via MCP in the coding agent harness so the agent can call it during planning, mid-execution, and review. Beyond the harness, also expose it to ask-engineering channels, ticket triage, and incident management. The MCP integration lets the agent request a fresh, scoped, conflict-resolved packet at each phase rather than crawling raw data.
How does the context engine handle vague or underspecified prompts?
It uses the social graph as a pivot point, keying on the requester's identity to zoom into the correct codebases, PR history, and collaborator signals. This makes vague prompts produce precise results because the engine infers the relevant scope from who's asking, then retrieves exhaustively within that scope and resolves any conflicting sources before responding.
At what team size does data governance become critical for a context engine?
Data governance becomes especially relevant at around 20+ team members, where permissions and role-based access matter. At that scale you must define which data is private and which roles can see what, then apply those rules at ingestion time. Skipping this risks surfacing sensitive information to agents or users who shouldn't have access.