Frequently Asked Questions About Unblocked Context Engine Framework
22 answers covering everything from basics to advanced usage.
// Basics
What is the difference between data access and organizational understanding for AI agents?
Data access means an agent can query a database, call an MCP, or read a file. Organizational understanding means the agent knows which patterns to follow, which shared services exist, who owns what, and how decisions were made. An agent with access but no understanding 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. The Context Engine bridges this gap.
What is a social graph in the context of AI coding agents?
A social graph maps engineers, their authorship history, code review relationships, and codebase ownership. It's built from commit history and PR data. When a query arrives, the context engine uses the requester's identity to pivot into the right codebases and collaborator signals. This turns vague prompts into precise, relevant results. Open-source tooling can generate this graph procedurally by pointing at a git repository.
What is a token-optimized research packet?
A token-optimized research packet is the compressed, precisely targeted context output that a context engine delivers to an agent before it begins execution. It contains only what the agent needs—relevant architectural patterns, existing services, ownership information, and resolved conflicts—not a raw data dump. The engine's job is to reason across all surfaces and compress the response down to the minimum viable context for the agent's specific task.
What data sources should I ingest into my context engine?
Ingest both static sources (documentation, CLAUDE.md files, runbooks, architecture decision records) and runtime sources (Slack/Teams conversations, pull requests, tickets, SaaS tool data, deployment records). Do not rely only on static stores—they go stale immediately. Runtime sources capture the real-time organizational state that static docs miss. Apply data governance rules at ingestion time so the engine respects access permissions from the start.
What's the minimum team size where a context engine makes sense?
A context engine becomes valuable as soon as you have enough organizational context that a single engineer can't hold it all in their head—typically around 5-10 engineers working across multiple services. At 20+ engineers, it becomes critical because no individual understands the full system, data governance rules become necessary, and the social graph provides meaningful personalization. Even smaller teams benefit if they have complex codebases with many integrations or patterns.
// How To
How do I audit where my team is on the Context Ladder?
Ask three questions: (1) Are engineers manually pasting context, pointing agents to files, or re-feeding information every session? That's stage 1—you are the context engine. (2) Do you maintain static files like CLAUDE.md or agents.md that agents read automatically? That's stage 2—curated context layer. (3) Does a dynamic system retrieve personalized, runtime-aware context on demand? That's stage 3—context engine. Most teams are at stage 1 or early stage 2.
How do I build a social graph from my git repository?
Extract commit history and PR review data from your git repository. Map each engineer as a node. Create edges representing review and collaboration relationships. Size nodes by commit volume to indicate ownership weight. Tag each node with the services and directories they own. Open-source tooling exists that can point at a git repo and generate this graph procedurally. The graph becomes the pivot point for personalizing all context retrieval.
How do I implement exhaustive retrieval instead of naive RAG?
Build retrieval that: (a) constructs a structured query from the agent's task, decomposing it into sub-queries covering architecture, existing services, ownership, and constraints; (b) traverses all relevant data surfaces—code, docs, conversations, tickets—exhaustively; (c) applies the social graph to scope retrieval to the right codebases and collaborators; (d) surfaces conflicts between sources rather than silently picking one. The key difference from naive RAG is that the system must not stop at the first plausible result.
How do I resolve conflicts between data sources in my context engine?
When retrieved data contains contradictions—for example, code in main implementing one pattern versus a Slack message from the CTO directing a different approach—the engine must settle the conflict. Use social graph authority signals (seniority, role) and recency to determine ground truth. A CTO's recent Slack directive outweighs an outdated implementation in main. Pass both the resolution and the original sources to the agent so it understands the reasoning.
How do I set up Plan-Execute-Review mode with a context engine?
Split agent execution into three phases. Phase 1—Planning: the agent calls the context engine to build an org-aware implementation plan before writing any code. Phase 2—Execution: the agent writes code following the plan and can re-call the context engine mid-task for clarification. Phase 3—Review: the agent or a human calls the context engine to review the output against organizational patterns. The engine delivers the most value at planning and review phases.
// Troubleshooting
My AI agent writes code that compiles and passes tests but gets rejected in code review—what's wrong?
Your agent is suffering from satisfaction of search—it finds the first plausible approach and stops retrieving context, missing your team's established patterns and shared services. The code is technically correct but organizationally wrong. You need a context engine that performs exhaustive retrieval, surfaces your architectural patterns and existing services, and delivers that context before the agent begins coding. This is the core problem the Unblocked Context Engine Framework solves.
Why is my AI agent stuck in doom loops where I keep correcting it?
Doom loops happen when the agent lacks organizational context and you're manually supplying it piece by piece. Each correction gives the agent one data point, but it still doesn't have the full picture. You're at stage 1 of the Context Ladder—you are the context engine. The fix is to build a system that delivers comprehensive, conflict-resolved context upfront so the agent's first attempt is architecturally correct, eliminating the correction cycle entirely.
My CLAUDE.md file is huge but my agent still produces bad code—why?
Static context files like CLAUDE.md are stage 2 on the Context Ladder—better than nothing but fundamentally limited. They go stale the moment they're written, they lack runtime signals from Slack conversations and recent PRs, someone must maintain them manually, and they can't personalize context to the specific engineer or task. You need to progress to stage 3—a dynamic context engine that retrieves fresh, targeted, personalized context at runtime.
My context engine is slow—can I cache frequently asked queries?
Do not cache context engine answers. A cached answer is a stale answer. Your codebase, conversations, and deployment state change constantly—the same question asked 24 hours later may have a different correct answer. Caching trades correctness for latency, and incorrect context is worse than slow context. Instead, optimize retrieval speed through better indexing, query decomposition, and social graph scoping. Accept latency as the cost of accuracy.
// Comparisons
How does the Unblocked Context Engine Framework compare to just using MCPs?
MCPs give your agent access to data—they're pipes to external systems. But access is not understanding. An agent with MCP access to 20 SaaS tools can call them, but it doesn't know which tool matters for its current task, which patterns your team follows, or how to interpret conflicting data. The Context Engine Framework sits above MCPs, using them as data sources while adding exhaustive retrieval, social graph personalization, conflict resolution, and token-optimized delivery.
How does a context engine compare to fine-tuning a model on my codebase?
Fine-tuning bakes organizational knowledge into model weights at training time—it's static, expensive, and becomes stale as your codebase evolves. A context engine provides dynamic, runtime retrieval that always reflects the current state of your code, conversations, and decisions. Fine-tuning also can't personalize results per engineer or resolve real-time conflicts between sources. For organizational context that changes daily, a context engine dramatically outperforms fine-tuning.
How is the Unblocked Context Engine Framework different from regular RAG?
Regular (naive) RAG places data in a vector store and lets the agent query it, which triggers satisfaction of search—the agent stops at the first plausible hit. The Context Engine Framework replaces this with exhaustive retrieval across all data surfaces, social graph scoping to personalize results, explicit conflict resolution between contradicting sources, and compression into a token-optimized research packet. It's the difference between giving someone a library card and giving them a researched briefing.
// Advanced
Can I use the context engine for non-coding tasks like incident management or ticket triage?
Yes—this is explicitly recommended. The same context engine that serves coding agents also delivers value in human-facing channels: auto-answering questions in Slack ask-engineering channels, enriching and triaging tickets, and assisting during incident management by querying across deployment records, runbooks, and recent communications. Building the engine only for coding agents wastes the investment. One engine serving all surfaces multiplies your leverage.
How does data governance work with the context engine at scale?
At 20+ team members, you need a permissions model applied at ingestion time. Define which data is private, which roles can see what, and enforce these rules when the context engine retrieves and delivers context. The social graph informs permissions—an engineer querying about a service they don't own may get a different (more restricted) context packet than the service owner. Data governance rules are an optional but critical input for larger organizations.
How do I expose my context engine to headless background agents?
Expose the context engine via an MCP server or API that headless agents can call programmatically at each phase—planning, execution, and review. The agent should call the engine before generating an implementation plan, optionally mid-task for clarification, and at the end for self-review. Since headless agents have no human to babysit them, the context engine's exhaustive retrieval and conflict resolution become the primary quality control mechanism.
How do I measure whether my context engine is working?
Track PR rejection rate for agent-generated code—it should drop significantly. Measure babysitting time: how many manual corrections per agent task. Monitor doom loop frequency: how often engineers have to re-prompt agents through multiple failed attempts. Track time-to-merge for agent-generated PRs. On the human side, measure engineering interruptions in Slack channels and ticket triage time. A working context engine improves all of these metrics.
Can I use the context engine with multiple AI models or agent frameworks?
Yes—the context engine is model-agnostic by design. It produces a token-optimized research packet that any LLM-based agent can consume. Whether you're using Claude, GPT, Gemini, or an open-source model, and whether your agent framework is Cursor, Copilot, a custom harness, or a headless CI agent, the context engine delivers the same organizational understanding. Expose it via MCP or API and any agent can call it at planning, execution, or review phases.