• 

• 

• 

• 

• 

• 

• 

• 

• 

The Problem

One thing I learned the hard way while building AI systems is that the bottleneck isn't model intelligence anymore it's coordination.

Modern coding agents like Codex, Claude Code, and Cursor are incredibly capable. They can spin up multiple sub-agents, search repositories, write code, run tests, and even coordinate complex development tasks. But underneath that impressive behavior, I kept noticing the same inefficiency:

Every agent repeatedly rediscovers knowledge that already exists. The same repository gets explored again. The same files are searched. The same workflows are planned. The same tool chains are executed. All of that reasoning consumes tokens, latency, and engineering time. While working on research around compute-aware multi-agent systems, I became fascinated by a simple question:

What if AI agents could learn from previous executions instead of solving every task from scratch?

That question eventually became Reforge.

Inspiration

The original idea came from a very practical problem. While collaborating with my co-founder on research and production AI systems, we often had multiple AI coding agents working simultaneously on different branches of the same repository. Although each agent had its own context window and memory, none of them knew:

• another agent had already solved a similar problem,
• which files were likely to conflict,
• which workflow had already been executed dozens of times. As our projects became larger, the amount of duplicated reasoning increased dramatically. The surprising realization was that we weren't limited by model capability—we were limited by the lack of shared organizational memory.

That inspired us to rethink AI-assisted software development.

What Reforge Does

Reforge is an intelligence layer that sits alongside AI coding agents. Instead of optimizing a single prompt, it continuously learns from how an engineering team works. It combines three key ideas:

Repository Intelligence

Reforge constructs a semantic graph of the repository, understanding relationships between files, modules, functions, documentation, and dependencies.

Instead of asking

"What files changed?" it understands

"What parts of the system are actually affected?"

Specification-Driven Collaboration

Before development begins, Reforge analyzes implementation plans and expected file changes. If two engineers—or two AI agents—are about to modify overlapping parts of the repository, Reforge detects the conflict early and suggests alternative implementation boundaries before any merge conflict occurs.

Instead of fixing merge conflicts after coding,

we try to prevent them before coding starts.

Workflow Learning

Every AI coding session becomes training data. Reforge observes:

• reasoning patterns
• tool usage
• repository navigation
• execution time
• repeated workflows

Using these traces, it identifies recurring execution patterns and automatically converts successful workflows into reusable skills.

Over time, AI agents spend less effort rediscovering the same solutions and more effort solving genuinely new problems.

How We Built It

The project was built using Codex with GPT-5.6 throughout development. Codex accelerated implementation by helping generate boilerplate code, iterate on repository graph logic, build UI components, and rapidly prototype backend services.

GPT-5.6 was used extensively during system design, architecture discussions, algorithm exploration, and refining the workflow optimization pipeline.

The system itself combines:

• repository graph construction
• semantic indexing
• workflow tracing
• execution analytics
• clustering of repeated procedures
• skill generation
• engineering dashboards

The frontend visualizes repository structure, repeated workflows, token usage, and automation opportunities, while the backend continuously processes execution traces into reusable organizational knowledge.

Challenges

The hardest challenge wasn't building dashboards. It was defining what "the same workflow" actually means. Two executions may use different prompts, different files, and different tool sequences while still representing the same underlying task. Designing a workflow representation that captures semantic similarity—rather than exact tool order—required several iterations.

Another major challenge was repository understanding. Traditional search techniques like grep or regex can locate files quickly, but they don't capture semantic relationships across functions, modules, documentation, and AI-generated skills.

Building a richer graph representation became essential for enabling higher-level reasoning. Finally, balancing optimization with flexibility was important.

We wanted Reforge to reduce repeated reasoning without taking control away from developers or AI agents.

What We Learned

The biggest lesson was that scaling AI isn't only about better models. It's about building better systems around those models. Today's coding agents already generate excellent code. The next leap forward won't come from asking them to think harder—it will come from helping them remember, coordinate, and reuse knowledge across teams and across time. In many ways, Reforge isn't trying to build a smarter AI.

It's trying to build a smarter engineering organization.

Looking Ahead

Our long-term vision is to create a continuous optimization layer for AI-assisted software engineering. As more workflows are executed, Reforge becomes better at understanding how teams build software, discovering recurring patterns, and turning those patterns into reusable organizational knowledge. We believe the future of AI development isn't just autonomous agents.

It's teams of agents that continuously learn from each other.

Built With

• agents
• ai
• automation
• claude
• code
• codex
• cursor
• docker
• fastapi
• git
• gpt-5.6
• graph
• langgraph
• neo4j
• next.js
• node.js
• openai
• postgresql
• python
• react
• repository
• tailwind
• typescript
• workflow