0G Forge

0G Forge is a terminal-native agent framework and CLI for building, modifying, synchronizing, and deploying AI-generated applications directly on the 0G stack.

The project targets a core bottleneck in the agentic software era: today, autonomous agents can reason and generate code, but they still lack a reusable infrastructure layer for turning multi-step goals into persistent, deployable, verifiable applications. 0G Forge solves this by providing a programmable development substrate that both human developers and autonomous agents can use from the terminal.

At its core, 0G Forge introduces a modular agent runtime built around three extensible primitives:

- AgentLoop — a goal execution engine with reflection-based decision making, allowing agents to continue, retry, skip, or stop after each step

- ToolRegistry — a flexible orchestration layer where agent capabilities can be registered and composed

- MemoryLayer — a backend-agnostic persistence layer for storing agent state, execution history, and long-context progress

These primitives power the included Goal Agent, a working autonomous example that can read a sequence of development goals, execute og create and og edit actions, reflect on the result of each step, persist its memory, and continue toward a finished application. In other words, 0G Forge is not only a developer CLI; it is an agent-native framework for autonomous app creation.

The project deeply integrates 0G’s infrastructure across the full execution lifecycle:

- 0G Compute powers AI inference for prompt-driven code generation and code editing

- 0G Storage stores project metadata, decentralized sync payloads, and persistent agent memory

- 0G Chain anchors verifiable project state through the deployed FrameworkRegistry contract, which records framework registration and the latest sync hash on-chain

Through commands such as og init, og create, og edit, og preview, og sync push/pull, and og deploy vercel, developers can move from an idea to a live application entirely from the terminal. At the same time, agent builders can use the Forge runtime as a foundation for more advanced autonomous coding agents, specialized skills, and long-running AI workflows.

0G Forge directly aligns with the hackathon’s Agentic Infrastructure track by focusing on orchestration, agent frameworks, state persistence, and real 0G-native execution. Rather than presenting AI as a single-prompt coding assistant, it demonstrates how 0G can become the infrastructure layer where autonomous agents continuously build, remember, verify, and ship software.

• Built the og CLI with init/create/edit/preview/deploy/sync flows and plan+diff pipeline.

• Implemented forge‑agent runtime (AgentLoop, ToolRegistry, MemoryLayer) and goal‑agent demo.

• Integrated 0G Compute inference, 0G Storage sync provider, and on‑chain FrameworkRegistry.

• Deployed FrameworkRegistry on 0G Mainnet and published updated npm package.

• Finalized frontend landing + docs and demo flow.
  
  
  During the hackathon, 0G Forge evolved from an initial concept into a working, 0G-native agent framework and CLI with end-to-end functionality.
  We designed and implemented the full terminal workflow for AI-generated app development, including og init, og create, og edit, og preview, og deploy vercel, and og sync push/pull. This allows developers to move from project scaffolding to code generation, refinement, decentralized synchronization, and deployment directly from the terminal.

  A major milestone was the development of the forge-agent runtime, which turns 0G Forge from a simple CLI into reusable agentic infrastructure. We introduced three core primitives:

  - AgentLoop for multi-step goal execution with reflection-based decisions

  - ToolRegistry for registering and composing agent capabilities

  - MemoryLayer for persistent agent state and execution history

  On top of this runtime, we built a working autonomous Goal Agent that can process development goals, execute Forge commands, evaluate each step, retry or skip when needed, persist memory, and continue toward a completed application.

  We also completed real 0G protocol integrations:

  - Integrated 0G Compute for prompt-driven generation and editing

  - Integrated 0G Storage for decentralized metadata sync and agent memory persistence

  - Deployed a FrameworkRegistry contract on 0G Chain mainnet to register the framework and store the latest sync hash on-chain

  In addition, we created the project’s technical architecture, modular monorepo structure, reproducible demo flow, environment configuration, local run instructions, and full README documentation for judges and developers.

  By the end of the hackathon, 0G Forge became a complete prototype of an agent-native development layer on 0G: not just a tool that generates code, but a framework that enables autonomous agents to build, remember, verify, and ship applications.

Not fundraising yet