NemoForge: Autonomous SWE Agent

• 

  LOGO

• 

  Diff changes

• 

  Flow tab

• 

  Indexed

• 

  UI

Inspiration

Current AI coding assistants remain superficial text generators. When introduced to multi-repository, production-grade enterprise codebases, they encounter severe architectural bottlenecks:

1. Quadratic Token Exhaustion: Blindly feeding raw repository files into large language model context windows produces high entropy, quadratic token consumption, and model confusion: $$\text{Entropy}(C) \propto \mathcal{O}(N^2) \quad \text{vs.} \quad \text{NemoForge AST Slicing: } \mathcal{O}(1) \text{ (<10ms deterministic lookup)}$$
2. Destructive Full-File Rewrites: Standard generative models frequently drop imports, break adjacent methods, or overwrite existing business logic when regenerating entire files.
3. The Unverified Patch Gap: Conventional tools output code suggestions without verifying whether the resulting codebase compiles, passes regression test suites, or satisfies user interface contracts.

We created NemoForge to transform autonomous software engineering into a deterministic, self-healing discipline. By coupling NVIDIA Nemotron 3 Super (120B MoE) hosted on Nebius Token Factory with a 10/10 Production Readiness Test Harness, a ReAct agentic execution engine, and an interactive React 18 real-time dashboard, NemoForge converts raw engineering tickets directly into fully verified, production-ready pull requests.

---

What it does

NemoForge operates as an autonomous, full-lifecycle software engineering agent:

• ReAct Autonomous Agent Engine: Orchestrates a continuous Thought -> Action -> Observation -> Reflection loop with native tool execution, language server protocol diagnostics, and compiler feedback cycles.
• Deterministic AST Discovery: Employs Tree-sitter parsers and an embedded SQLite Write-Ahead Logging (WAL) database to map class hierarchies, dependency injection annotations (such as Spring @Autowired), and method-to-method call graphs in under 1 second without external graph database dependencies.
• NVIDIA Nemotron Reasoning on Nebius Token Factory: Directs architectural planning, ticket scope proving, and cross-service logic synthesis to NVIDIA Nemotron 3 Super (120B MoE), utilizing Nemotron 70B Instruct for high-speed triage.
• Speculative Sandboxing: Executes all modifications in isolated, ephemeral workspace branches, preventing local repository pollution or dirty git states until every verification gate passes.
• Zero-Hallucination Surgical Patching: Implements a fail-closed 3-line anchor diff algorithm that replaces targeted AST nodes while preserving formatting, whitespace, and surrounding logic.
• Two-Tier Verification Gate: Enforces a strict multi-stage verification pipeline across compilers and end-to-end tests: $$\mathcal{V}(\text{Patch}) = \begin{cases} \text{PASS} & \text{if } \text{Compiler}(\text{Patch}) = 0 \land \text{PlaywrightE2E}(\text{Patch}) = \text{PASS} \ \text{SELF-HEAL} & \text{otherwise (Feed diagnostic logs back to Nemotron)} \end{cases}$$
• Interactive React 18 Dashboard: Delivers a live Execution DAG state-machine viewer, bi-directional WebSocket telemetry streaming, and a side-by-side visual Git diff inspector.

---

How we built it

Intelligence and Model Routing

• Primary Reasoner: NVIDIA Nemotron 3 Super (120B MoE) for cross-service architectural reasoning and code generation.
• Inference Infrastructure: High-throughput Nebius Token Factory API targeting OpenAI-compatible endpoints.
• KV Prompt Cache Manager: Structured prefix caching reducing token latency and costs by up to 68%.
• Episodic Experience Store: Vector-free memory layer capturing verified patch patterns and domain knowledge across execution runs.

Backend and Agent Runtime

• Core Stack: Python 3.12, FastAPI, Uvicorn, and asynchronous event loops.
• Agent Orchestrator: ReActAgentEngine featuring autonomous reflection, token budget ceiling guards, and non-blocking decision coordinators.
• Security Jail: CommandSafetyValidator rejecting destructive command patterns (such as recursive directory removal, path traversal, and credential scraping).
• Embedded Symbol Database: SQLite in WAL mode storing symbol tables, relationships, and call edges locally (.nemoforge/index.db) for sub-10ms queries.
• Compiler Sandbox: Polyglot build execution supporting Maven, Gradle, npm, and pytest.

Frontend and Operator Interface

• Application Layer: React 18, Vite, and glassmorphic user interface components.
• Execution DAG Visualizer: Dynamic visual representation of workflow nodes and active pipeline states.
• Real-Time Telemetry: Persistent WebSocket connection broadcasting live token generation, AST indexing progress, and build logs.
• Surgical Diff Viewer: Color-coded side-by-side diff display rendering precise code additions, deletions, and anchor lines.

Benchmarks and Evaluation

• Evaluation Workspace: CloudForge-Commerce, a distributed polyglot e-commerce architecture containing Spring Boot microservices (Order Service, Settlement Service) and a React frontend.
• Golden-50 Evaluation Harness: 50 end-to-end benchmark scenarios measuring symbol localization accuracy, compilation pass rates, and regression prevention.
• 10/10 Production Readiness Suite: Formal test harness validating command safety, state store durability, storage synchronization, and cancellation safety.

---

Challenges we ran into

1. Eliminating External Database Overhead: Early prototypes tested graph and vector databases (such as Neo4j and vector indexes), but connection latency, memory overhead, and cold-start times degraded user experience. We resolved this by building a custom Tree-sitter SQLite WAL indexing engine, reducing repository indexing time to under 1 second.
2. Patch Application Integrity: Standard LLM diff outputs often fail native git apply commands due to mismatched line counts or loose context. We engineered a 3-line anchor replacement algorithm that validates pre- and post-context anchors before executing the patch.
3. Closing the Self-Healing Loop: Synthesizing code without validation is insufficient for production. We constructed a closed feedback loop that captures build failures and compiler stack traces, passing them back into the ReAct cycle so Nemotron can self-correct errors autonomously.
4. Cross-Platform Zero-Friction Setup: Creating seamless 1-click execution across Windows (setup.bat, start.bat) and Linux/macOS (setup.sh, start.sh) required rigorous dependency minimization and virtual environment linking without mandating Docker setup.

---

Accomplishments that we're proud of

• 10/10 Production Readiness Harness: Achieving full test passes across all enterprise resilience categories, including path security, state recovery, and token ceilings.
• Sub-Second Repository Indexing: Indexing 46 files, 112 symbols, and call graph relationships in less than 1 second on standard developer hardware.
• Full-Stack Polyglot Verification: Autonomously compiling Java backend microservices, building TypeScript/React frontends, and executing Playwright browser tests end-to-end.
• High-Throughput Nebius Token Factory Integration: Seamless streaming inference with NVIDIA Nemotron delivering rapid token generation and reliable tool-calling performance.

---

What we learned

• Static Analysis Complements LLM Reasoning: Deterministic AST parsing provides exact ground truth of class hierarchies and method contracts, allowing NVIDIA Nemotron to focus its reasoning budget purely on logic synthesis rather than searching through text.
• Targeted Context Trumps Volume: Providing an LLM with 50 lines of surgically extracted symbol definitions and call signatures yields far higher patch accuracy than flooding context with thousands of lines of unparsed source files.
• Iterative Verification is Mandatory: Software engineering requires continuous verification against compilers and test suites. Pairing NVIDIA Nemotron with automated sandbox execution mirrors how experienced software engineers write, test, and debug code.

---

What's next for NemoForge: Autonomous SWE Agent

• Multi-Repository Federation: Expanding the AST symbol graph across multiple disparate repositories within enterprise GitHub organizations.
• Continuous Integration GitHub Action: Distributing NemoForge as an automated GitHub Action that triages newly opened issues, writes the code, verifies builds, and submits completed pull requests.
• SWE-Bench Comprehensive Benchmark: Running the Golden-50 harness against the complete SWE-Bench Verified dataset to establish public state-of-the-art benchmarks.

Built With

• 10/10-production-readiness-suite
• autonomous-agents
• episodic-memory
• fastapi
• golden-50-evaluation-harness
• kv-prompt-caching
• maven
• mixture-of-experts-(moe)
• nebius-token-factory-api
• npm
• nvidia-nemotron-3-super-(120b-moe)
• nvidia-nemotron-70b-instruct
• playwright-e2e
• pytest
• python-3.12
• react-18
• react-agent-architecture
• speculative-sandboxing
• sqlite-wal
• static-code-analysis
• swe-bench
• tree-sitter-ast
• two-tier-verification-gate
• vite
• websockets