Search

Tuesday, September 8, 2026

Agentic Development in Practice: How Six AI Agents Built a Web Game - and What Broke

Part 6 of the AI Agents series. The full build story of the browser-playable Snakes & Ladders arena that the six-role software company from Part 5 delivered — beginning, as these things do, with the two times it failed first.

This is a field report on agentic development: what actually happens when you hand a real software project to autonomous AI coding agents and let them run a full development lifecycle. Most guides to agentic coding describe the theory — the roles, the loops, the guardrails. This one is the evidence: three attempts, two abandoned toolchains, a hallucinated graphics API, an AI-issued quality certificate that certified a layer it had never tested, twenty-eight defects closed without being repaired, and a finished game you can play in your browser right now. If you want to know whether AI agents can build software — and, more usefully, how you would ever know — that is what this post is about.

What this post covers:

  • Why this game was built three times — twice as native C, by two different agentic drivers, and both times it died.
  • What a hallucinated API actually looks like when the compiler grades it, including the subtler case of a function that was real once and has since been removed.
  • A QA certificate declaring the application 100% defect-free whose own footnote admits it never tested the layer containing the only visible bug.
  • The stretch where my own instruments were wrong four times in a row and the person watching the screen was right every time.
  • Twenty-eight defects found by an independent reviewer, closed without being repaired, and then actually repaired.
  • Why a finished, tagged, CI-green project needed a week and a full rollback to survive meeting one phone.
  • The finished game running on 19 GitHub-hosted runners across three operating systems and two CPU architectures.
Browser game built by autonomous AI coding agents - the finished Indian Snakes and Ladders arena mid-game: a procedurally generated ten-by-ten board with speckled SVG snakes and two-rail ladders, four coloured player tokens in play, an animated die, and a live commentary panel listing recent moves.

The finished arena, playing itself. Procedural board, SVG snakes and ladders, four autonomous players, twelve audio cues — and no build step anywhere in sight.

In Part 5 I forked a production coding CLI into a six-role software development company — CEO, CPO, CTO, programmer, reviewer and tester, running as native subagents on free NVIDIA NIM models. That post was about the harness. It closed by naming the thing the harness actually produced and promising the details here: a four-player Indian Snakes & Ladders arena that plays itself in any browser, with no build step and no server.

This is that story. It does not begin where you would expect, because the browser was not the plan. It was the third plan.

Friday, September 4, 2026

Build a Six-Role AI Software Company by Forking Kimi Code: Multi-Agent SDLC on NVIDIA NIM

Part 5 of the AI Agents series. A six-role software development company — CEO, CPO, CTO, programmer, reviewer, tester — running as native subagents inside a downstream fork of the Kimi Code CLI, powered by free NVIDIA NIM (Nemotron) models, verified on six platforms, and shipping a browser-playable Snakes and Ladders arena.

What this post covers:

  • How to build a multi-agent AI software development team that runs an end-to-end SDLC (inception, blueprint, code, review, test) inside a single coding CLI session.
  • Why forking a production coding CLI (Kimi Code) is a better fit than assembling a separate multi-agent framework (ChatDev, AutoGen, CrewAI) for real-world software delivery.
  • How to make an OpenAI-compatible NVIDIA NIM (Nemotron 3 Ultra 550B, Nemotron 3 Super 120B) endpoint work with a client that assumes Kimi/Anthropic API conventions.
  • A step-by-step install of pre-built binaries on Linux (x64 / ARM64), macOS (Intel / Apple Silicon), and Windows (x64 / ARM64).
  • Honest engineering post-mortems: the WaitFor timeout saga, a GitHub Actions YAML parse bisect, and provider-compatibility gotchas for OpenAI-compatible gateways.
  • A live browser deliverable — a four-player Indian Snakes & Ladders arena — produced end-to-end by the agent team.
Six subagents (ceo, explore, cto, programmer, reviewer, tester) active in a single kimi session on Nemotron 3 Super 120B via NVIDIA NIM, closing out a bad-regressions report against a snakes-and-ladders workspace. Sixty-two minutes in; four subagents already checkpointed and closed, tester still running the verification suite across 153 tool calls.

Six subagents on Nemotron 3 Super 120B via NVIDIA NIM, in one kimi session, closing out a bad-regressions report against a Snakes and Ladders workspace. Sixty-two minutes in; the tester is still running the verification suite across 153 tool calls.

For four posts now this blog has been running someone else's virtual software company — ChatDev 2.0, wired up to free NVIDIA NIM models, and put through progressively harder assignments: a smoke test on Linux, a live AI news debate wall, a cross-platform Ludo game, and finally a public GitHub release stress-tested on eleven runners. The framework held up. Along the way it also demonstrated, in Part 3, that a green build and a passing test suite can quietly ship a completely broken headline feature; and, in Part 4, that "it works on my machine" reliably hides four defects until the code lands on a machine that was not the author's.

This post moves the company one layer down. Instead of using someone else's multi-agent AI framework and someone else's models, SANYALnet Labs now owns the coding harness itself. The virtual software company is no longer a Python process orchestrated from outside; it lives inside a downstream fork of a production AI coding CLI, as six bindable subagents — autonomous coding agents that share a single session, a single model, and a single conversation transcript. This is agentic SDLC done as one continuous transcript, not a message bus between processes.

Tuesday, August 4, 2026

Publishing an AI-Built Game: Eleven Runners, Two CPU Architectures, Four Hidden Bugs

Runbook · Public release & CI proof · Part 4

SANYALnet Labs Ludo AI Arena rendered on an Arm64 Linux GitHub Actions runner with no display attached: the full cross-shaped board, four AI player cards, the die, and a scrolling event log.
A complete game played on an Arm64 Linux cloud build machine with no monitor, no desktop and nobody watching. The application drew this picture of itself.

Publishing an AI-Built Game: Eleven Runners, Two CPU Architectures, Four Hidden Bugs

In Part 3 of this series, ChatDev 2.0 built SANYALnet Labs Ludo AI Arena—a C#/.NET 10/Avalonia desktop game in which four autonomous AI players play a full match by themselves. Five free models failed at it; one paid DeepSeek run costing about a dollar shipped it. The post ended with the game running on four machines in my house, and a build report from the agents declaring everything green. Both of those statements were true. Neither of them meant the software was actually finished.

Saturday, August 1, 2026

Build a Cross-Platform Ludo Game with ChatDev 2.0: Free AI Models Fail, a $1 DeepSeek Run Ships It

Runbook · Multi-agent application build · Part 3

SANYALnet Labs Ludo AI Arena running on Linux: a rendered cross-shaped Ludo board with four AI players, a die, and an event log showing model-generated move reasoning.
The finished game: four autonomous AI players, a live event log of model-chosen moves, and a die that flashes without shoving the board around.

Building a Desktop Game with ChatDev 2.0: When Free AI Models Fail, and a One-Dollar DeepSeek Run Ships It

In Part 2 of this series, ChatDev 2.0 took a detailed specification and built a Live News Debate Wall—a self-contained Python web service that turned business headlines into a fictional AI-parody debate. That project answered a friendly question: can the virtual software company build a real application from a real spec? It could. This time the question was less friendly.

Tuesday, July 28, 2026

Build and Run a Live AI News Debate Wall with ChatDev on Linux

Runbook · Multi-agent application build

Live News Debate Wall interface showing fictional AI-parody responses from POTUS, the European Commission president, Gronk Vellumthud and Yoda, with RSS and model health indicators.
ChatDev’s finished Live News Debate Wall turns live business headlines into an AI-parody debate—complete with policy, bureaucracy, Vogon poetry and Yoda.

Building a live AI news debate wall with ChatDev 2.0: from requirements prompt to a tested Linux service

In the first part of this series, I installed ChatDev 2.0 on Linux, connected its virtual software company to an OpenAI-compatible GLM endpoint, and proved that the complete agent graph could design, write, review, test and deliver a runnable program. This time, the factory gets an actual assignment.

Friday, July 24, 2026

DO NOT PANIC: Free Windows Stock Market Dashboard

DO NOT PANIC Portfolio Visualizer Windows stock market dashboard with ticker tapes, floating charts, market indicators and city background
DO NOT PANIC Portfolio Visualizer turns delayed market data into an animated, full-screen financial display.

Stock-market dashboards usually resemble spreadsheets that have acquired several extra panels and begun making demands. We wanted something different: a financial display that could live on a second monitor, office screen, television, or wall-mounted panel without looking like an accounting department had occupied the room.

The result is DO NOT PANIC Portfolio Visualizer 1.0, a free animated stock market dashboard for 64-bit Windows 10 and Windows 11. It combines delayed portfolio quotes, four customizable ticker tapes, floating charts, global market clocks, macro indicators, financial headlines, and rotating city or stock-exchange backgrounds. It is now available from the project’s official GitHub release and its itch.io download page.

Thursday, July 23, 2026

Install ChatDev 2.0 on Linux: AI Agents That Build Real Software

Runbook · Multi-agent software factory

Building software with a team of AI agents: installing ChatDev 2.0 and passing a full-lifecycle smoke test

For a while now I've wanted to break out of the closed ecosystems I write code in every day — OpenAI's ChatGPT and Codex, Anthropic's Claude and Claude Code. The reason is simple: the free, openly available models have been closing the gap with the $20-a-month subscription tiers so quickly that paying for a walled garden increasingly feels like a habit rather than a necessity. That instinct was sharpened by Bill Gurley's July 2026 Washington Post opinion piece — Gurley, president and founder of the P3 Institute and a former venture capitalist, argues that the flood of powerful models being given away for free is not a security threat but ordinary competition: the oldest strategy in software, cost leadership, driving price down toward the near-zero cost of copying a model. It is, in the essay's words, simply "what competition looks like." Convinced that the open side is where the momentum now lies, I went hunting for a serious free-model toolchain to build real software with — and ChatDev is the most promising thing I found.