Source: SiliconANGLE — 2026-07-14
Summary
Concho AI launched a platform that pre-analyzes large, sprawling enterprise codebases into a semantic knowledge graph — what its CTO calls a "cognitive precompiler" — and exposes that understanding to existing coding assistants like Claude via MCP, instead of asking developers to adopt a whole new tool. Rather than an agent re-exploring files from scratch every session, it queries a "fact layer" that already understands the codebase's architecture and business behavior. Clearwave, a medical technology company, is using it to spread tribal knowledge about medical-coding logic across teams without routing every question through a small group of experts.
Key Takeaways
- The core idea is doing the expensive codebase-understanding work once, ahead of time ("cognitive precompiler"), rather than having every agent session re-derive architecture and intent from raw files on the fly.
- It plugs into existing assistants via MCP rather than requiring a separate coding agent or IDE — the knowledge layer sits underneath tools teams already use.
- The "fact layer" framing positions this squarely as a code-specific memory/RAG system: instead of embedding-based retrieval over raw source, it's a structured knowledge graph over what the application actually does.
- Concho's flagship customer example, Clearwave, uses it to encode domain-specific logic (medical coding and pricing rules that don't cleanly map to standard docs) so that knowledge scales past the handful of people who originally held it.
Reel Script
Hook: Every time your coding agent opens a huge legacy codebase, it re-learns the whole thing from scratch — burning tokens and time on understanding it already paid for yesterday. Concho AI is betting that's the wrong architecture.
Core Concept: Most coding agents work like a new hire who gets zero onboarding notes and has to re-read the entire codebase cold, every single day, before they can answer a question. Concho's approach is to build that onboarding once — analyzing the codebase into a knowledge graph, a structured map of how pieces of the system relate and what they actually do, not just their raw text — and let agents query that map instead of re-reading source files from scratch. The company's CTO calls this a "cognitive precompiler": doing the expensive interpretation work ahead of time so each individual query is cheap.
Hands-On: The plumbing here is worth sketching out: Concho sits between your codebase and your existing assistant, exposed through MCP, so a tool like Claude doesn't need to be replaced — it just gets a new tool call that returns pre-digested facts about the system instead of raw grep results. Picture the flow as: codebase → Concho's precompiler builds a knowledge graph once → agent asks a question via MCP → Concho returns structured facts, not files. The real-world proof point is Clearwave, a medical technology company, using it to hold onto tribal knowledge about medical-coding and pricing logic — rules that don't map cleanly to any standard documentation — so that knowledge doesn't bottleneck on the two or three people who originally understood it.
Takeaway: This is the pattern worth watching in the "agent memory for code" space: separate the expensive understanding step from the cheap query step, and expose it through a protocol your existing tools already speak instead of building a walled garden. If your team's coding agents keep burning context re-deriving the same architectural facts every session, that's the gap a layer like this is built to close.