• 

  Platform & Problem Loading

• 

  NemotronCoder Final Telemetry Summary

• 

  Compiler Testcases: PASSED

• 

  Live Ace Editor Typing + Terminal HUD

NemotronCoder: The Autonomous Coding Agent That Replaces Repetitive Student Lab Work

Inspiration

Across engineering colleges and universities, hundreds of thousands of students face a grueling, daily grind: repetitive programming lab assignments and assessment portals. In my college, peers spend countless sleepless nights manually navigating rigid assessment platforms, copy-pasting boilerplate code, struggling with minor syntax quirks, and doing the same repetitive typing tasks across hundreds of daily challenges instead of focusing on deep algorithmic problem-solving.

I asked myself: "Why should students waste hours on mechanical repetition when an autonomous AI agent can observe the sandbox, understand the problem, synthesize the code, and debug it in real time?"

This sparked the birth of NemotronCoder—an autonomous agent powered by NVIDIA Nemotron via Nebius Token Factory that acts as an intelligent co-pilot and automated benchmark solver. It takes over the heavy lifting: reading problems, deciphering visual challenge verifications, writing optimized multi-language code, injecting it into live web IDEs, and self-debugging compiler errors until all test cases pass.

What It Does

NemotronCoder completely automates the lifecycle of solving coding lab assignments on live web platforms:

1. Autonomous Environment Navigation: Launches a stealth browser, logs into the coding portal, and discovers pending modules, chapters, and challenge tracks without any human intervention.
2. Multimodal Visual Checkpoint Solving: When platforms present visual checkpoints or math verification captchas, NemotronCoder captures the canvas and uses an NVIDIA Vision model to decode and solve the checkpoint with zero-shot accuracy.
3. Algorithmic Synthesis with NVIDIA Nemotron: Scrapes the problem statement, locked skeleton code, and constraints, then prompts NVIDIA Nemotron (nvidia/nemotron-3-super-120b-a12b / nvidia/Nemotron-3_5-Lightning) running on Nebius Token Factory to generate clean, idiomatic solutions in C, C++, Python, or Java.
4. Natural Web IDE Interaction: Simulates natural human keystrokes with Gaussian typing distributions and micro-pauses directly inside complex browser code editors (Ace Editor).
5. Closed-Loop Self-Healing: The agent clicks Run, observes the live compiler output, and if a syntax or runtime error occurs, extracts the compiler traceback, escalates its reasoning temperature, updates its session memory, and autonomously patches the solution until green checkmarks appear.
6. Live Observability Dashboard: A full-stack FastAPI + SQLite dashboard allows users to monitor real-time solve rates, track session telemetry, view token latency, and inspect logs.

How We Built It

• Cloud & Serverless Inference: Built on Nebius Token Factory (https://api.tokenfactory.nebius.com/v1/), providing high-throughput, ultra-low-latency serverless access to open-weight models.
• Reasoning Brain: NVIDIA Nemotron family (nvidia/nemotron-3-super-120b-a12b & nvidia/Nemotron-3_5-Lightning) for multi-step algorithmic planning, edge-case generation, and dynamic code repair.
• Vision Perception: Multi-modal vision models to decipher visual math challenges and diagrammatic problem inputs.
• Browser Orchestration: Engineered with Python & Playwright Stealth, bypassing canvas locks and interacting seamlessly with embedded code editors.
• Telemetry & Dashboard: Developed with FastAPI, Jinja2, and SQLite, logging every session attempt, error rate, and model response in real time.

Challenges We Faced

1. Handling Complex Web Editors: Web platforms don't use simple <textarea> inputs—they use complex canvas-backed editors (like Ace Editor). We had to craft custom key-event simulation and cursor positioning to type code cleanly without breaking indentation.
2. Context-Aware Dynamic Self-Healing: Standard LLM retries often loop into the same syntax error. We engineered an adaptive memory feedback loop: if the compiler returns an error, the agent feeds the exact compiler error back into Nemotron with elevated temperature and explicit negative constraints.
3. Speed & Latency in Real-time Loops: Waiting 20+ seconds per problem ruins the automation flow. Routing our requests through Nebius Token Factory drastically cut inference latency down to under 2 seconds, making real-time autonomous execution possible.

Accomplishments That We're Proud Of

• Autonomous Problem Solving: Successfully solved over 100+ real college lab problems across C, C++, and Python with zero human intervention.
• Lightning Fast: Achieved sub-3-second end-to-end cycles (problem scraping ➔ Nebius Token Factory inference ➔ execution ➔ result).
• Resilient Self-Correction: Built a self-healing loop that fixes syntax errors, missing includes, and index bounds errors in real time.
• Production-Grade Observability: Built a sleek, live web dashboard to monitor student session progress, pass/fail ratios, and system health.

What We Learned

Harnessing open-weight powerhouse models like NVIDIA Nemotron on ultra-fast infrastructure like Nebius Token Factory proves that open-source AI is fully capable of real-world autonomous software engineering. You don't need expensive proprietary walled gardens to build reliable, closed-loop agents.

What's Next for NemotronCoder

• "Tutor Mode": Transforming the agent into an interactive AI tutor that doesn't just solve problems, but explains step-by-step algorithmic concepts and time complexity to students.
• Multi-File Codebase Refactoring: Extending the agent from single-file challenges to multi-file repository bug fixes and automated pull request creation.
• Direct IDE Integration: Building a VS Code extension powered by Nebius and Nemotron for in-editor autonomous testbench generation.

Built With

• artificial-intelligence
• automated-testing
• autonomous-agents
• computer-vision
• fastapi
• llm
• nebius
• nemotron
• nvidia
• playwright
• python
• sqlite