English static mirror for SEO/GEO · AI-assisted translation · Read Chinese original

StarNet: Your Pixel-Art Space Station Layout Is the Agent Workflow That Actually Runs

Forum topic · ✨步子哥 · 2026-09-25

Summary

StarNet is a local-first desktop agent harness where the pixel-art space station you draw is not a visualization of the workflow—it is the runtime itself. Rooms define capability-scoped teams of agents, corridors act as authorized handoff channels between rooms, and placed objects grant real permissions such as GitHub access. The project enforces a strict product rule: the interface must never assert state the harness cannot prove, rejecting fake 'agent is thinking' animations. Key features include independent concurrent agents with isolated workspaces, a leashed and auditable Night Shift mode, Task Briefs that ask users instead of silently guessing (via Telegram, Discord, Slack, Signal, Matrix), MCP connectors, and a real spending ledger persisted to disk. Compared with frameworks like Paperclip or AutoGen, StarNet targets individuals and small teams running 3–10 agents, and introduces a 'spatial programming' paradigm where non-technical users can design agent workflows by drawing layouts. Repo: https://github.com/androoAGI/starnet.

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
  • 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:

  • Workspace (file-system isolation)
  • Conversation history
  • Memory
  • Permission boundaries
  • 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:

  • Paperclip: agents are employees—org charts, hierarchy, governance
  • StarNet: agents are station crew—spatial layouts, capability objects, corridor authorizations
  • 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

  • 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

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

Tags

#ai-agents#agent-framework#spatial-programming#local-first#pixel-art#mcp#multi-agent#developer-tools

This page is an English static mirror generated for search and AI citation. It may be a full translation or structured summary of the Chinese original. Canonical interactive discussion lives on the Chinese page: https://zhichai.net/topic/178635212