Forge

Forge helps coding agents share evidence-backed decisions, not noisy chat history—turning validated lessons into local project rules that make every session stronger.

Comment

Inspiration

We’re Jeel Patel and Aksh Patel, friends and students from India who started learning to build through AI-assisted coding.

Jeel had already spent months exploring the context problem. After falling in love with vibe coding through Codex, he built Context Bridge to manage context across multiple AI tools and is now building Cortex, a structured approach to context management. That work revealed a deeper problem: agents do not only lose context—they lose the decisions behind the work.

Aksh came to the problem from the builder’s side. He began learning coding with curiosity—and some fear of making major mistakes. AI coding tools made development more approachable, but he quickly saw that even capable agents lose momentum when they do not know which approaches were tried, why a decision was made, or what was already validated.

As students relying on limited free usage across tools such as Codex and Antigravity, switching agents often meant manually re-explaining our project, repeating research, and hoping nothing important was lost. Forge began as our answer: not a way to store every conversation, but a way to preserve the decisions that matter.

What it does

Forge is a local-first decision and learning system for coding agents.

When an agent finishes a session, Forge saves a structured handoff: the goal, the problem, the decision made, what changed, why it changed, what was validated, and what remains. The next agent receives the relevant decision instead of a large, noisy transcript.

Forge also connects decisions to local evidence such as Git activity and validation results. When trusted outcomes repeat, Forge can turn that lesson into a scoped project rule—helping future agents avoid repeated mistakes and make better decisions.

Forge is not about remembering everything. It is about helping a project remember what it learned.

How we built it

Forge was built in just three days during OpenAI Build Week.

Jeel led the product direction and backend/system thinking, drawing on his earlier context-management projects. He focused on the core decision flow: how an agent records a handoff, how evidence supports it, and how validated outcomes can become reusable project guidance.

Aksh focused heavily on user experience and frontend development. He helped make Forge understandable at a glance through the dashboard, Learning System, and Session Handoff views—turning complex engineering decisions into something developers can inspect and trust.

Together, we built Forge with:

  • Python and FastAPI for the backend
  • SQLite for local-first storage
  • Model Context Protocol (MCP) tools for agent integration
  • Local Git evidence and optional GitHub review data
  • React, TypeScript, and Vite for the dashboard
  • GPT-5.6 and Codex throughout the building, debugging, and iteration process

Challenges we ran into

The biggest challenge was deciding what an agent should preserve.

Saving all context sounds useful, but raw chat histories can be noisy, difficult to trust, and privacy-sensitive. We had to design Forge around a more focused idea: preserve the decision, the reason behind it, and the evidence that supports it.

We also had to think carefully about rules. We did not want Forge to create arbitrary instructions from a single claim. The system needed a way for repeated, validated outcomes to become scoped rules while keeping developers in control.

We were learning while building. Jeel went deeper into product hardening, data design, local-first architecture, and open-source system design. Aksh pushed through frontend challenges and learned that mistakes are part of building—not a reason to stop.

GPT-5.6 and Codex helped us reason through architecture, debug issues, improve the interface, and turn a rough idea into a working beta within a short timeframe.

Accomplishments that we're proud of

We are proud that, in three days, we turned a problem we personally experience into a working beta product.

Forge already supports:

  • Structured, transcript-free Session Handoffs
  • Local, privacy-conscious decision storage
  • Evidence-backed engineering context
  • MCP-based coding-agent integration
  • A Learning System for observing validated outcomes
  • Scoped project rules based on trusted evidence
  • A dashboard for decisions, handoffs, coordination, and learning
  • Developer control over sensitive decisions and rule changes

Forge is still in beta. It is not the final version of our vision—but it is a real foundation that proves the core idea: every agent session can make the next one stronger.

What we learned

Jeel learned how to take an idea he had explored through earlier projects and develop it into a more complete, production-minded system. He learned more about data modeling, safety, product decisions, and building software people can trust.

Aksh learned that coding is not about avoiding mistakes—it is about investigating, fixing, and improving them. He gained confidence in frontend development and learned how much product quality depends on making technical systems clear and approachable.

Together, we learned that AI-assisted development is not only about writing code faster. It is about preserving judgment, learning from outcomes, and helping humans stay in control.

What's next for Forge

Forge is currently a beta, and we see this hackathon build as the first step—not the final destination.

Next, we want to improve installation, deepen coding-agent integrations, refine the dashboard, strengthen evidence and validation workflows, and test Forge with more real developers and teams.

We also want to improve how Forge identifies repeatable lessons, proposes scoped rules, and supports teams working across multiple agents and worktrees.

Our goal is to make agentic development feel cumulative instead of fragmented: every session should leave behind a better decision for the next one.

Built With

Share this project:

Updates