Sector 001: A Galactic War Where the Commanders Think for Themselves

By the SynaptixLabs Team

---

What happens when you hand two autonomous AI governments a war and tell them to win?

That is the question behind Sector 001 — a Star Trek galactic war simulation set in the 2374 Borg Incursion, Federation against the Borg, the line drawn at Earth. On the surface it is a turn-based strategy game: a 24-system galaxy, fleets moving between stars, cubes bearing down on Sol. Underneath, it is something stranger and more useful — a proving ground for multi-agent orchestration, where the commanders are meant to reason rather than follow a script. The Chief of Staff argues grand strategy. The Admiral makes the fast call in the middle of a battle. The Scientist, after a loss, goes away and invents the counter-tech. Between turns, they are supposed to think.

Building that is brutal. And the most interesting decision the team made was to not build most of it.

The problem: a war is brutal on AI

A turn-based galactic war is one of the hardest things you can ask an AI to run, because it asks for several different kinds of thinking at once, all under hard constraints.

A Chief of Staff has to hold grand strategy across the whole galaxy — which front to reinforce, which system to trade away, when to gamble. An Admiral has to make fast tactical decisions in the middle of a battle, where the situation changes every exchange of fire. A Scientist has to look at a defeat and propose new technology that answers it — without breaking the game. Every one of those decisions has to happen under a fixed compute budget, every one has to be auditable after the fact, and not one of them is allowed to cheat the rules of the universe it lives in.

You cannot get that by hard-coding behaviour. Hard-code a strategist and you get a puppet: it does exactly what you anticipated and nothing you didn't, which is the opposite of a worthy opponent. But the alternative looks even worse. Building a whole agent stack — model routing, memory, budgets, tool-calling, validation, a way for skills to evolve — inside a game engine would bury a small team in plumbing they have no business owning. The war would never get built because everyone would be busy reinventing an agent platform badly.

So Sector 001 made a clean cut down the middle of the problem.

The solution: the game owns the war; the minds run on Nexus

Sector 001 builds zero agents of its own. This is written into its design, not bolted on: per the integration spec (05_SPEC_agents_integration.md), the game does not build agents — it consumes them. The simulation owns the things a simulation should own — the galaxy, the turn loop, the battle physics, the rules — and it consumes reasoning from Nexus, our Agents-as-a-Service layer, over REST and SSE.

The division of labour is exact. Sector owns WarState, the battle engine, action validation, and the victory rules. The agents own reasoning, decisions, and skill evolution. The game is the world and the referee; the agents are the minds. Nothing crosses that line.

The cast is eight agents — four per faction: Chief of Staff, Admiral, Commander, Scientist — organised as two crews, one per side, each orchestrated by its Chief of Staff. (A HiveRunner handles the crew-level post-battle analysis, where a faction sits with what just happened to it.) Each agent acts only through tools the game defines — move_fleet, allocate_resources, set_priority, set_formation, focus_fire, order_retreat, set_targeting_policy, set_weapon_mode, propose_discovery — every call returning structured JSON. The contracted API surface is concrete: POST /api/chat, /api/chat/stream, /api/hive/simulate, and a /api/skills CRUD.

And here is the part that makes Agents-as-a-Service more than a slogan: which model runs which mind is a routing decision, made once, in the harness — not in the game. The Chief of Staff and the Scientist, who do the slow, expensive, reasoning-heavy work of strategy and invention, are routed to Claude Sonnet. The Admiral and the Commander, who need split-second tactical calls during a battle, are routed to Groq's llama-3.3-70b — cheap, fast, low-latency. The game never knows or cares. It asks for a decision; Nexus decides who answers and on what model. Change that routing tomorrow and not a line of game code moves.

Below is a hands-on taste of the world those commanders will fight over. You take the helm of the U.S.S. Enterprise-E, with the Defiant on your wing, against a Borg Cube that adapts — phaser damage decaying as it learns your weapon, forcing you to switch to torpedoes. Click empty space to move, click a Borg or an asteroid to lock phasers, and fire torpedoes with the button or the spacebar. Watch the wingman's mode in the HUD, and the orange Nexus routing console beneath the battle — an illustrative read-out of which agent, and which model, would own each call.

Figure: a scripted Sector 001 skirmish — Defend Earth. This is a self-contained Canvas game with a SCRIPTED enemy AI: no network, no model, no crew, no LLM. The "Nexus · AaaS routing" console is an illustrative demonstration of the wingman's mode, captioned as such — it is not a live agent call. As the on-screen line says: in full Sector-001 the fleet commanders are autonomous agents that LEARN. The Earth-integrity bar, scores, and adaptation meter are the demo's own constants.

Governance is the control flow, not a policy

Autonomy is only safe when it is bounded, and Sector 001's bounds are real code rather than good intentions.

Every faction crew runs under a hard budget — 50,000 tokens and 20 calls per turn — enforced by a resource_manager. A strategist with infinite compute is not a strategist; it is a stalling tactic. The budget forces the same scarcity a real command staff lives under.

Every decision is validated before it touches state. Because agents act only through game-defined tools that return structured JSON, Sector can check each move against WarState and the rules of the universe, and reject illegal moves before they apply. An agent cannot teleport a fleet, spend resources it doesn't have, or bend the victory conditions — the six-phase turn loop (Strategic, Movement, Battle, Analysis, Science, End Turn) runs over a fixed 24-system galaxy graph (9 Federation systems, 8 Borg, 7 neutral) with six fleets and three ways to win: capital conquest, total domination, or three-turn majority control. The agents play inside those rules; they do not get to edit them.

And evolution itself is bounded. After a loss, the discovery pipeline kicks in: it generates about three upgrade proposals, the Chief of Staff selects one, and a schema validator does the rest. discovery.py defines per-stat STAT_BOUNDS and a MAX_CHANGE_PCT = 25 — no single upgrade may move a stat by more than 25% — and every upgrade must be bounded, explainable, and forbidden from invalidating the faction's identity (the Borg stay the Borg). A skill registry tracks each skill's success_rate and usage_count and caps every faction at 30 evolvable skills, pruning the rest. The fleet can get smarter between wars, but only within a fenced, auditable space. That is the difference between a system that learns and a system that drifts.

Memory closes the loop. Each agent keeps memory scoped to the war session — storing post-battle analysis and telemetry summaries, retrieving faction context for the next turn's decisions, and tracking per-commander experience down to kills and losses. A defeat is not just a reset; it is something the crew remembers and reasons over next time.

Where it actually stands — and what is honestly not done

This is where we have to be plain, because it is the most important thing on the page.

The LLM commanders are not live yet. Sector 001 is real software at a real milestone — it is built in Python 3.12 on Pygame-CE, sitting at v5.1-mvp4 in Sprint 44, with 690+ tests (526 headless unit tests that run under SDL_VIDEODRIVER=dummy in about 27 seconds, plus an 11-scenario visual end-to-end suite that produces 59 screenshots). The war, the galaxy, the battle engine, the six-phase turn loop, the validation, the bounded discovery pipeline — those exist and are tested. But the agent layer is currently mocked. The file agent_interface.py is headed, in the team's own words, "Mock implementation that mirrors the Nexus AGENTS API contract. Swap MockAgentClient → RealAgentClient when AGENTS platform is ready," and the README lists "Nexus AGENTS platform (for real agent integration — currently mocked)" as a dependency.

So the honest claim is this: the Agents-as-a-Service architecture is designed, contracted, and validated against a faithful rule-based mock — the integration is contract-complete, and the war runs end to end against a stand-in that mirrors the Nexus API exactly. The live Nexus swap-in is the in-development milestone, not a shipped fact. We are not running autonomous LLM fleets today; we have built everything around the seam so that turning them on is a client swap, not a rewrite.

The performance story is bounded too, and we would rather say so than imply otherwise. Logic-only frame rates are excellent at small scale — about 4,275 FPS at 10 ships, 290 at 50 — marginal at 57 FPS at 100, and unplayable at 8 FPS at 200. The honest ceiling today is roughly 100 ships per battle. Canon-scale fleets — the 600-to-1,500-ship armadas of the actual Borg Incursion — are flagged as needing a dedicated optimization sprint or an engine migration; Godot 4 is under evaluation for MVP5, which makes it a plan, not a delivery.

The playable demo above is, by design and by its own banner, a presentation piece: a scripted Canvas skirmish, no model behind it. The wingman that picks ENGAGE, INTERCEPT, TORPEDO, or REGROUP is running a small rule-based strategy, surfaced in the HUD as a deliberate foreshadow of the real commanders. We label it that way on purpose. The point of the demo is to make the world legible — to let you feel what it is to hold a line that adapts against you — not to pretend the minds are already home.

The throughline

Strip away the starships and Sector 001 is the cleanest version of an argument we keep making: a product should own its domain and consume its intelligence.

The game owns the war — and it is genuinely good at owning the war. It does not own a model, a router, a budget enforcer, a memory store, or a tool-validation layer, because those are not a war game's job. They are the platform's job, built once and governed once for every product that consumes them. That is what lets the same harness that defends an inbox, or runs a banking red-team, also command a fleet. The shape is identical. The agents decide; the game transports.

The ships, it turns out, were the easy part. The minds run on Nexus.

---

Sector 001 is a SynaptixLabs project, currently in development — the Nexus agent integration is contracted and mock-validated, with the live swap-in as the active milestone. It is a fictional Star Trek war game; no real-world data is presented. The agents it is built to consume run on Nexus, our Agents-as-a-Service layer, by design: a product should consume intelligence, not reimplement it. Talk to us.

— The SynaptixLabs Team