Blitzy's $1.4B Bet: Why Coding Agents Need Knowledge Graphs to Understand Entire Systems

The shift toward autonomous software development is pushing knowledge graphs into a central role. When coding agents operate on large, interconnected systems, they must grasp the full scope of what their changes affect. The more extensively an agent modifies code, the more dependencies and connections it needs to comprehend. This challenge has attracted significant investor attention to platforms designed specifically to address it.

Blitzy Inc. secured $200 million in funding at a $1.4 billion valuation in May, positioning itself to run thousands of coding agents simultaneously. The core difficulty in autonomous coding extends beyond the mechanics of code generation itself. According to Neeraj Deshmukh, director of engineering at Blitzy, the real bottleneck lies elsewhere: "I think when people talk about changing software autonomously, the biggest problem is not whether AI can write code. It's about does AI know or understand the system that it's writing the code for?" Deshmukh explained that understanding matters because a single code change in one location can trigger unforeseen consequences elsewhere in the system.

Why knowledge graphs fit the shape of code

Blitzy's approach begins by analyzing a customer's existing infrastructure and constructing a dynamic graph representation of the codebase. This graph integrates with version control platforms like GitHub and GitLab, updating automatically whenever developers or agents modify code. The choice to use knowledge graphs aligns with a fundamental characteristic of how software itself is organized, as Deshmukh noted: "Fundamentally, code is a graph because you think about, 'Oh, we have modules, we have files, we have functions, we have objects, we have classes, variables.' Each of these are entities that are related to each other. So even before you bring AI into the picture, a codebase is a graph intrinsically."

Without this structured approach, agents resort to vector searches or grep commands to identify dependencies, consuming their available working memory rapidly. An agent's practical context window maxes out around 200,000 to 300,000 tokens, equivalent to roughly 20,000 to 30,000 lines of code. When facing a 100-million-line codebase, agents must compress results, inevitably discarding information. Graph-based navigation solves this: "With a graph, you know exactly what you're going to reach because you basically get to pick the point where you want to start. And you know exactly what is accessible. And so you have that effective context. Every agent knows the context that it needs to and nothing else," Deshmukh said.

This efficiency transforms project planning. Since less context gets lost to unfocused searches, Blitzy can address entire projects in one go rather than fragmenting work into traditional sprints with epics, user stories and individual tasks. The platform embeds quality assurance directly into its workflow: humans must approve an Agent Action Plan before coding starts, and every generated line undergoes immediate testing. Blitzy reported an 84.95% score on SWE-Bench Pro in June.

Additional safeguards involve agents monitoring other agents to verify compliance with the approved specification and plan. "That ensures that there is no drift or hallucination," Deshmukh stated. The choice of query language provides another layer of protection. Blitzy's agents continuously execute queries using Neo4j's Cypher language, and Cypher's rigid syntax acts as a built-in safety mechanism. When an agent produces a malformed query due to hallucination, it simply returns no results. "You only get a result for a correct query," Deshmukh explained. "So there is no question of the agents working off of made-up information or something false. You're always grounded in truth of what's in the knowledge graph."

https://www.youtube.com/embed/j8P2nLXLldI?feature=oembed