Living devlopment workspace for agents: Nabi Station

This is a submission for the Hacktoberfest Open-Source AI Challenge Week 2: Side Hustle

What I Built

I work on multiple projects and with several AI coding agents in parallel every day.

The problem is visibility. It is easy to lose track of which agent is still working, which one is waiting for input, which project has failing tests, or which repository needs attention—especially when my screens are being used for something else.

At the same time, projects need to meet engineering standards such as documentation, testing, linting, CI, and maintainability.

So I built a visual control room for AI-assisted development.

Projects become buildings in a miniature city, AI agents become workers, and project status is visible at a glance. I can see what is active, what needs attention, and inspect or act on a project directly.

Gemma running locally through Ollama adds the intelligence layer. It analyzes project structure and documentation, summarizes activity, and recommends what a project could improve next.

Open-source AI matters because source code, terminal activity, and repository metadata are sensitive. With a local open-weight model, this analysis can stay on the developer's own machine without sending the codebase to an external AI provider.

As developers start managing more AI agents in parallel, I think we need better ways to manage the work they are doing.

Instead of watching ten terminals, manage one living development workspace.

Who would pay for it

• Developers like me, who run several agents across several repositories and have stopped being able to keep it all in their head.
• Freelancers and small agencies juggling client repositories also fit, because they have to show that every project meets the same standards and cannot send client code to a third-party AI to check it.

Demo

Code

Reterics / Nabi-Station

Nabi Station

Nabi Station is the isometric view of the repositories and coding agents already running on this machine. Claude Code, Codex, and Cursor stay visible when the screens are on something else. Each repository is checked for documentation, tests, and the rest of the quality bar, and a local Gemma model writes the recommendation and a prompt to paste back into the agent.

A local daemon reads those sessions without modifying either tool. Without it the page shows a "Not connected" notice. Sample data appears only at ?demo.

Run locally

Requires Node.js 22.13+ (for node:sqlite) and pnpm 9.9.0 (the pinned package manager). The character models the app serves live in assets/dist as ordinary git files. Git LFS is only needed to edit the source files under assets/src (git lfs install and git lfs pull).

pnpm install
pnpm dev

Open http://127.0.0.1:5173. The development server binds…

View on GitHub

pnpm install
pnpm dev                          # demo city at http://127.0.0.1:5173/?demo
pnpm build && pnpm nabi serve D:/git   # live mode: your repositories and agents

How I Built It

Open-source AI: Gemma, Google's open-weight model, served locally by Ollama. The default model is gemma4:12b, and any other installed Gemma is used if that one is missing.

Nabi Station has three parts:

1. A local daemon (Node.js, TypeScript). It scans folders for git repositories and watches agent sessions, all read-only:
   • Claude Code: session files checked against the live process, plus the tail of the transcript for the current tool and file.
   • Codex: its SQLite state, opened read-only.
   • Cursor: agent transcripts and the IDE's composer index.
   • Only metadata is parsed: tool names, paths, turn status and timestamps. Message text, credentials, .env files and source files are never opened.
2. A deterministic assessment. About 20 checks turn each repository into a maturity tier, from empty plot to production-ready, plus an activity level. This decides what the building looks like. The model is never asked to decide it.
3. A React 19 + Three.js (React Three Fiber) city. It uses an orthographic isometric camera, procedural buildings for six archetypes, and rigged GLB characters for each agent type with ten animation clips.

Where Gemma fits. I deliberately kept the model away from the facts and gave it the judgement.

• The input is the deterministic assessment (each check, its status and its evidence) plus short excerpts from the README and architecture docs.
• Gemma writes: strengths, prioritised improvements with the reason for each, and a "fix with an AI agent" prompt with acceptance criteria. The prompt covers the medium- and high-priority items and is written for Claude Code, Codex or Cursor running in that repository.
• The output is validated against a Zod schema and cached under ~/.nabi/cache/recommendations/, keyed by the exact input. The same repository state never costs a second inference.
• If Ollama is missing or slow, or Gemma answers badly, the panel says so and shows nothing invented.

The result is a loop that closes on the developer's own machine: the city shows a repository falling behind, Gemma explains what to do about it, and one click copies the task into the agent that is already working there.

Privacy and security are part of the design, not an afterthought:

• The daemon listens only on 127.0.0.1 and refuses foreign Host headers.
• Every WebSocket connection must present a per-start token.
• The Ollama host must be loopback unless you explicitly opt out.
• The web app makes no external requests at runtime.

Why Does Open Innovation Matter?

A tool that watches every agent session and reads the docs of every repository I have is exactly the kind of tool I would never connect to an external AI provider. Running Gemma locally is what makes the product possible:

• Nothing leaves the machine. The daemon, the assessment and Gemma all run locally, and that is enforced in code: loopback-only Ollama by default and no runtime requests from the page. This matters even more for the freelancer case, because client contracts often forbid uploading their code anywhere.
• It costs nothing per analysis. Recommendations run on demand and are cached by input, so watching fifteen repositories doesn't come with a per-token bill. A closed API would make "analyse every repository I touch" a running cost, and the free core would stop making sense as a business.
• It's mine to change. Ollama lets me swap Gemma sizes (NABI_OLLAMA_MODEL) for the hardware I have. Open weights mean I can fine-tune for my own engineering standards later without asking anyone's permission or worrying about a pricing change.
• It works offline. On a plane, behind a VPN or on an air-gapped client network, the city and the recommendations still work.

Prize Categories

• Best Use of Gemma: Gemma, running locally through Ollama, writes every repository recommendation and the agent fix prompts. The rest of the design is built around keeping that inference on the developer's machine.