StarNet: Your Pixel-Art Space Station Layout Is the Agent Workflow That Actually Runs
> Source: GitHub repository androoAGI/starnet > Date: 2026-09-26 > Repository: https://github.com/androoAGI/starnet > Trending: +118 stars in one day
TL;DR
StarNet is a local-first desktop agent harness—you place rooms, corridors, and objects in a pixel-art space station, and the layout you draw is the workflow the agents actually run. Not a simulation, not a visualization: it is, literally, the runtime.
Opening Scenario
You open a pixel-art space station editor on your desktop. Draw a room called "Engineering" with two agent desks, each with a "coding" badge. Draw a corridor to a "Testing" room, label the corridor "code handoff," and place an agent with a "testing" badge there.
Hit run.
The Engineering agent starts writing code. The finished code flows through the corridor to Testing. The Testing agent runs the tests automatically; on failure, it sends a bug report back through the corridor. You watch pixel characters walking around the screen—but every movement corresponds to a real API call, a real tool execution, a real cost.
This is not a simulation game. This is StarNet.
Core Design: Space Is the Program
StarNet's most counter-intuitive property: the UI is not a visualization of the runtime—the UI is the runtime itself.
Most agent frameworks treat the UI as a "dashboard"—agents run in the background, and the UI displays status. StarNet inverts this: what you draw in the UI directly defines the agents' capability boundaries, collaboration paths, and permission scopes.
Concretely:
- A room = a capability-constrained team: agents in a room share that room's capability set
- A corridor = an authorized handoff channel: work can only pass between rooms connected by a corridor
- A placed object = a real capability grant: only by placing a "GitHub access" object can agents operate on repositories
- Workspace (file-system isolation)
- Conversation history
- Memory
- Permission boundaries
- Paperclip: agents are employees—org charts, hierarchy, governance
- StarNet: agents are station crew—spatial layouts, capability objects, corridor authorizations
- Individual/small-team agent orchestration: 3–10 agents with visual collaboration
- Non-technical participation in agent design: PMs and designers can draw layouts
- Multi-channel interaction needs: control desktop agents remotely via Telegram
- Education/demos: pixel art + spatial layouts are great for teaching and showing
This means: layout is architecture. Want engineering agents unable to touch the database directly? Don't draw a corridor from Engineering to the database. Want all agents to use search? Place a "search" object in every room.
This is not "visual configuration"—it is a spatial programming paradigm.
Product Contract: The Interface Must Never Assert State the Harness Cannot Prove
StarNet has one core product law:
> The interface must never assert state the harness cannot prove.
Every pixel-level status on screen must have corresponding runtime evidence. If the interface says "agent is working," that agent is really making API calls. If it says "task complete," there really are output files. If it says "spent $2.50," $2.50 was really consumed.
The deeper meaning: StarNet refuses to fake it.
Many agent frameworks show "agent is thinking" or "agents are collaborating"—but those states may be fake, just UI animations playing while nothing happens in the background. StarNet bans this common deception outright.
It also means: if you see a thriving station—every room lit, every agent moving—your agent organization really is running efficiently. If it's dark, nothing is really happening. The UI won't lie to you.
Key Features
Multi-Agent Concurrency, Each with Its Own Workspace
Each agent is an independent running instance with its own:
Not "one agent with multiple windows"—multiple independent agents running concurrently.
Night Shift
Agents keep working after you leave your desk, but on an "explicit, adjustable leash"—every overnight action is logged and reviewable.
The design is elegant: it acknowledges the need for autonomous overnight operation while constraining risk with a leash plus audit logs. Not neglect—constrained autonomy.
Task Briefs — Ask Instead of Guessing
When facing ambiguity, agents don't silently guess—they send a Task Brief: the ambiguity becomes a concrete question with options, sent to you through a connected channel (Telegram, Discord, Slack).
This solves a real pain point: the agent guessed wrong and you come back to find it spent 3 hours on the wrong thing. Task Briefs replace "the cost of guessing wrong" with "the cost of answering one question."
Multi-Channel Access
Agents connect to Telegram, Discord, Slack, Signal, and Matrix. Chat with your space-station agents from your phone via Telegram to adjust work or approve tasks.
The station runs locally, but interaction is cross-device.
MCP Connectors
Supports Model Context Protocol servers—plug in any MCP-compatible tool: databases, APIs, file systems.
A Real Ledger
Spending, budgets, and run history persist to disk and are shown as-is. Not "estimated cost"—actual tokens consumed × price.
How It Differs from Other Agent Frameworks
| Dimension | Paperclip | AutoGen | StarNet | |---|---|---|---| | Core metaphor | Company | Conversation | Space station | | Programming style | Config + org chart | Code | Spatial layout | | Role of UI | Dashboard | None | The runtime itself | | Local-first | No | Yes | Yes | | Multi-channel | No | No | Yes | | Auditing | Yes | No | Yes (Night Shift logs) | | Best for | Large agent orgs | Developers | Individuals / small teams |
StarNet and Paperclip represent two extremes:
Both metaphors work, for different scenarios: Paperclip for 20+ agent teams, StarNet for 3–10 agent individuals or small teams.
Deeper Insight: Spatial Programming
StarNet's most notable contribution isn't the pixel art—it's spatial programming as a paradigm.
Traditional agent configuration is textual: YAML, JSON, Python. You must read the config to understand capability boundaries.
StarNet's configuration is spatial: what you see is what's real. No corridor from Engineering to the database? Engineering agents genuinely cannot touch it. No "deploy" object in Testing? Testing agents genuinely cannot deploy.
The fundamental shift: non-technical people can "program" agent workflows. A product manager can draw a station layout that defines how agents collaborate—without writing a line of code.
This differs from No-Code platforms. No-Code hides code behind a UI. StarNet replaces code logic with spatial relations—it doesn't hide complexity, it eliminates it through a more intuitive representation.
Limitations and Risks
1. Expressiveness ceiling of the spatial metaphor: not every workflow fits a spatial layout. Complex conditionals, loops, and exception handling may be harder to draw than to code. 2. Local-first = single-machine bottleneck: all agents run on your machine. Can 10 agents making concurrent API calls hold up? 3. Fragility of "interface as runtime": if the UI has a rendering bug, does it affect the runtime? Tight coupling means UI problems can become runtime problems. 4. The "decorative" pixel-art debate: some see pixel art as a gimmick. But StarNet's philosophy is "spatial relations as programs"—pixel art is merely the visual representation; swap in 3D or wireframes and the core logic is unchanged.
Who It's For
Closing Thoughts
StarNet advances a radical design philosophy: the interface is not a visualization of the runtime—the interface is the runtime itself.
The deeper implication: our notion of "programming" may be too narrow. Programming doesn't have to be code, YAML, or drag-and-drop flowchart nodes. It can be drawing a spatial layout—as long as that layout has explicit runtime semantics.
StarNet's core product law—"the interface must never assert state the harness cannot prove"—is a principle every agent framework should learn from. It's not just UI design; it's an honesty principle: don't pretend your agents are working if they aren't.
In an era when more and more frameworks use flashy UI animations to mask "nothing is actually happening," this principle matters more than any feature.
---
> StarNet repository: https://github.com/androoAGI/starnet > Trending data: +118 stars/day, JavaScript