Blitzy unlocks infinite code context for autonomous software development with Neo4j

5-10x

Faster delivery of features

100M+

Lines of code Blitzy’s agents work across

Writing code is the easy part

Blitzy builds enterprise grade software with a platform that runs completely autonomously for days or weeks at a time. The Cambridge, Massachusetts based company reverse engineers a customer’s codebase, whether it holds 1 million lines or 100 million, and constructs a world model of the system in a graph. Then, driven by a human created and approved spec, orchestrates a combination of frontier LLMs and deterministic techniques to write code, test it and return a globally validated pull request.

Blitzy often completes more than 80% of entire epics of work in this fashion. Its customers include Global 2000 companies in financial services, insurance, manufacturing, healthcare, and technology.


Neeraj Deshmukh, Blitzy’s Member of Technical Staff and Field CTO, says writing code is no longer the hard part. “It is well known that most frontier models are capable of writing vast quantities of code that on the surface is quality.” he said at GraphSummit New York 2026. “The question is not whether AI can code. The question now is, does AI understand the system in which it is coding?”

In a large enterprise, that system can hold tens of millions of lines written over decades. Some Blitzy customers run code that dates back more than 40 years. In Deshmukh’s example, an agent updates a discount calculation correctly but doesn’t know the same logic runs in 14 other places. “If the agents don’t have context for what this code is doing, what this code change is doing, then you’re going to get failures in production,” he said. The usual fix is to give the model more context. At enterprise scale, Blitzy found that approach runs out of room quickly.

A 100-million-line codebase won’t fit in a prompt

Models advertise context windows of a million tokens, but Deshmukh said much of that space goes to compaction, task management, and memory. “Effectively, what you’re left with is about 200,000 to 300,000 tokens of effective context,” he said. “That translates to about 20,000 to 30,000 lines of code.” Once a task has to follow the code past that limit, output quality degrades. Blitzy calls this “context anxiety.”

Longer prompts and memory files such as agents.md hit the same wall. Without a structured map, agents trace dependencies with vector searches or grep commands, and on a 100-million-line codebase those results fill the window fast. “You’re going to start compacting things. You’re going to start basically losing information in the process,” Deshmukh told theCUBE. “This just doesn’t scale.”

Blitzy co-founder and CEO Brian Elliott puts the mismatch in six words: “Context is serial. Information is relational.”

Code is already a graph

Deshmukh’s team started from the shape of the data. “A codebase is intrinsically a graph in principle. Modules, files, functions, classes, and variables are all entities related to each other,” he said. “Neo4j lets us mirror that structure and pair it with vector representations of metadata, and that vector graph hybrid gives us a powerful knowledge representation. For Blitzy, the knowledge graph is the linchpin for everything we do to develop software autonomously at enterprise scale.”

There are three ways to answer one question: “What depends on this?” A relational database stores links as foreign keys, and joins get heavier with every hop. Deshmukh told theCUBE that queries running “100, 200 levels deep” are “simply not sustainable.” Vector search finds code that looks alike but can’t confirm a connection. “You can find what’s similar, but not what’s related,” he said. 

Neo4j stores relationships as first-class data, and its index-free adjacency turns each hop along a dependency chain into a direct pointer instead of a scan. “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,” Deshmukh said. “Every agent knows the context that it needs to and nothing else.”

Blitzy’s agents query the graph in Cypher, Neo4j’s query language, which Deshmukh called “very LLM friendly.” To find every function that calls a target function, up to two hops out, an agent asks:

MATCH (fn:Function {name: ‘target’})

MATCH (caller:Function)-[:CALLS*1..2]->(fn)

RETURN caller.name

That precision is also a safeguard. If an agent hallucinates and writes a malformed query, the query fails and returns nothing. “You only get a result for a correct query,” Deshmukh said. “So there is no question of the agents working off of made-up information. You’re always grounded in the truth of what’s in the knowledge graph.”

Vector finds the neighborhood, graph finds the dependencies

Agents use the vector graph hybrid to retrieve code in three steps. A vector search narrows the work to the right neighborhood of the codebase. A graph traversal follows the verified relationships from there. Then grep pinpoints the exact file the agent has to change. Neo4j’s native vector index keeps the embeddings and the graph structure in one database, which Deshmukh called “a huge technical advantage for us.”

The graph also anchors Blitzy’s delivery process. After ingestion, the customer declares their intent for the target state, its constraints, and its success criteria in a spec. Agents use the graph to execute impact analysis, blast radius calculations and technical design, drafting what Blitzy calls an Agent Action Plan Architects and engineers approve the Agent Action Plan before any code is written. Agents then build the code and test every line as they go, running unit, functional, and regression tests and plugging into the customer’s CI/CD pipelines. Blitzy delivers a pull request and a project guide that lists what was done, how it was tested, and what remains for the customer’s engineers. 

Blitzy connects to source control systems, including GitHub, GitLab, Bitbucket, and Azure DevOps, and updates the graph whenever code changes, whether a Blitzy agent or a developer made the change. Agents never get direct access to customer repositories. The platform pulls code through the source control APIs and passes it to agents in pieces, a design Deshmukh said matters to customers in regulated industries.

Whole projects at once, not sprints

Because each agent can retrieve the context it needs, Blitzy no longer breaks work into epics, user stories, and tasks sized to what a person or a model can hold in mind. “Our customers don’t have to break a big problem into smaller pieces,” Deshmukh said. “They can take on projects as whole entities and get code that is demonstrably correct, functional, tested, and aligned with their enterprise guardrails for auditability, governance, and compliance.”

Blitzy says it delivers features and modernization work at five to ten times the speed engineering teams reach today, even with AI tools. Deshmukh said work that would take an engineering team a year, Blitzy can finish in less than two months.

The graph also tells customers what their oldest code does. One customer had spent nine months and $4 million with a systems integrator trying to reverse-engineer 30 million lines of COBOL, without success. Blitzy did it in three days. “You guys basically gave this to us over a weekend,” the customer told Blitzy, according to Deshmukh.

Use cases

  • Knowledge graph

Industry

  • Software

Products Used

  • Neo4j Enterprise
  • Americas

Explore more