A Pile of MCP Connectors Is Not a Context Engine
Unblocked argues that giving an agent access to Slack, Jira, and GitHub through separate connectors isn't enough, because the agent still has to search each silo, reconcile conflicting answers, and guess at unwritten team conventions. Its benchmarks claim up to 83% faster task completion and about 40% fewer tokens with a context engine doing that work upfront.
- Per-source connectors return documents from one system, so cross-source questions like "why does the payment service retry like this?" force the agent to assemble answers itself at inference-time token cost.
- Connectors can't tell which source is current when a Confluence page, a later Slack thread, and a PR comment disagree; the article says a context engine resolves contradictions with recency and authority signals before answering.
- Unwritten conventions and expertise patterns exist only across systems over time, so no query can retrieve them. The article's benchmarks show a 9.5/10 convention-following score with context versus 2/10 without.
- Each direct connector adds its own credential and permission model, which the article presents as a security burden that a single server-side connection reduces.
MCP connectors give an agent access to one system at a time, and that's the core complaint here. Plug in a Slack server, a Jira server, and a GitHub server, and each returns matching documents from its own silo. That works fine for known-item lookups like "fetch PR #4821." It falls apart on questions like "why does the payment service retry like this?", where the answer is scattered across a year-old PR review, an unrecorded Slack argument, a won't-fix Jira ticket, and the code. The agent has to do the stitching itself, guessing keywords, following links, and stuffing every intermediate result into its context window. The author, who works on Unblocked, argues that this is slow, costly, and error-prone, and that the work belongs in a separate "context engine" that does assembly before the agent asks.
The benchmarks carry most of the weight. On a Kotlin SDK task, the agent with Unblocked context finished 83% faster, used 48% fewer tokens, cost 60% less, and scored 9.5/10 on following team conventions versus 2/10 without context. On a frontend feature-toggle task, the gains were smaller (26.6% faster, 41.6% fewer tokens), and the agent without context never produced working code. An internal Claude Code comparison is the most striking: without Unblocked, 81 subagent turns and roughly 84% of a session costing about 10x more, still wrong; with it, a correct answer in 40 seconds. These are vendor-run numbers, and the author admits as much by open-sourcing a simulator so readers can test on their own repos. Worth treating as a claim to verify rather than settled fact.
The article also makes two conceptual points that are more persuasive than the numbers. First, agents don't know what they don't know: teams use different names for the same project across Slack and Jira, and key decisions get settled in PR comments, so there's nothing to query for. Second, sources contradict each other. A Confluence page can say one thing while a later Slack thread reverses it, and a connector-based agent will stop at the first plausible hit. The author says the engine resolves this using recency and authority signals, with citations so humans can check. The last section pushes further, arguing that unwritten conventions and real expertise topology (who actually knows a service, versus who the org chart says) exist only as patterns across systems over time, which no per-source query can reconstruct. Readers should keep in mind that the solution being pitched is the vendor's product, so the case against "just connectors" is partly a sales argument, though the underlying problems are real.