StarNet: Run real AI agents together in a local pixel-art station
A local desktop station for developers to run real AI agents, where pixel rooms become capabilities and workflows.
GitHub androoAGI/starnet Updated 2026-09-26 Branch feat/harness-backend Stars 476 Forks 91
JavaScript Local AI agents Node sidecar Ollama Tauri Windows/macOS

🧭 Decision Guide

Why trending now: 无法从材料判断

Try it if you

  • You need to run multiple AI agents concurrently on Windows 10/11, with separate workspaces and bounded permissions.
    The README’s “Features” and “Download” sections state that each agent has its own workspace, transcript, memory, and bounded permissions; Windows 10/11 has a 64-bit installer.
  • You want to use an Ollama local model without configuring an API key or account.
    The README’s “Run free with a local model” section says to run `ollama pull llama3.1`, choose `OLLAMA`, and connect to `127.0.0.1:11434`.
  • You need to connect agents to Telegram, Discord, Slack, Signal, or Matrix.
    The README’s “Features” section, “Message it from anywhere,” lists Telegram, Discord, Slack, Signal, and Matrix.
  • You need agent memory, transcripts, spend, tasks, and schedules persisted on disk.
    The README’s “What is real” section explicitly says these data persist on disk.

Skip it if you

  • Your target deployment is a public Linux desktop release.
    The README’s “Download” section explicitly says Linux packages are internal build artifacts and not a supported public release target.
  • You require a local model to match cloud-model speed and quality on long tasks.
    The README’s “Run free with a local model” section says Ollama local models are smaller, slower, and rougher on long tasks.
  • You need to use the StarNet name, logo, or station artwork directly in a commercial derivative distribution.
    The README’s “License” section says MIT covers only the code, and forks must use their own name, logo, and artwork.
  • You only accept a runtime that never sends provider requests outside the machine.
    The README’s “Run from source” section says provider requests leave the machine when an agent runs; station state, transcripts, memory, and ledgers remain local by default.

Requirements

  • Source execution requires Node.js 18+; the README says Node.js 22 matches CI.
  • Source execution requires Git.
  • Rust and Tauri prerequisites are required only when developing the desktop shell.
  • Using Ollama requires installing Ollama and running `ollama pull llama3.1`.
  • The public Windows release provides `StarNet__x64-setup.exe`.
  • On Apple Silicon macOS, use the native `StarNet__aarch64.dmg`; do not use the `x64` DMG.

First step (verbatim from README)

git clone https://github.com/androoAGI/starnet.git

Watch out

  • On Apple Silicon, use `StarNet__aarch64.dmg`; the x64 DMG runs through Rosetta 2.
    The Apple Silicon note in the README’s “Download” section.
  • When running from source, you must start `node sidecar/index.js`; the README lists it as the sidecar startup command.
    README “Run from source” section.
  • API keys are not imported from OpenClaw or Hermes; they must be re-entered in the KEYS tab.
    README “Coming from OpenClaw or Hermes?” section.
  • The `npm run qa:ready` READY receipt becomes invalid after a new commit, requiring affected live gates to be rerun.
    README “Testing” section.
  • `npm run security:secrets` requires Gitleaks to be available in PATH.
    README “Testing” section.

Alternatives

  • OpenClaw：Better when you already have an OpenClaw home and want to keep its existing agent environment instead of importing it into StarNet.
    README “Coming from OpenClaw or Hermes?” section
  • Hermes：Better when you already have a Hermes home and want to keep the Hermes runtime instead of migrating its persona, instructions, memory, and model.
    README “Coming from OpenClaw or Hermes?” section
  • Ollama：Better when you only need local model execution and do not need StarNet’s pixel-art space, multi-agent features, OUTBOX, or connectors.
    README “Run free with a local model” section

Not stated in the README

  • The README does not specify minimum hardware requirements for Windows or macOS.
  • The README does not list specific supported Anthropic, OpenAI, or Google models or version ranges.
  • The README does not state resource limits or recommended scale for concurrent agents.
  • The README does not quantify the speed and quality difference between Ollama and cloud models on long tasks.
  • The README does not provide a time series explaining the 478 stars, 91 forks, and 24 issues.
  • The README does not state which specific feature or fix is included in StarNet v0.12.4 released on 2026-09-26.
  • The README does not define the test matrix behind macOS having “less real-world coverage.”
  • The README does not explain the setup steps or permission scope for Telegram, Discord, Slack, Signal, or Matrix connectors.

💡 Deep Analysis

6
No I can only use a Linux workstation and require a supported public release package comparable to Windows 10/11 64-bit and macOS; is StarNet suitable for this deployment constraint?
For: A developer planning to deploy StarNet on a Linux workstation and expecting public release packages and support comparable to Windows 10/11 64-bit and macOS

No. The README explicitly limits Linux builds to internal artifacts, while public releases support only Windows and macOS.

  • The Download section lists public assets for Windows 10/11 64-bit, macOS Apple Silicon, and macOS Intel only.
  • It states: “Linux packages are internal build artifacts only and are not a supported public release target.” That conflicts with a requirement for an official public package.
  • The Node sidecar can still run from source using only Node core modules, but that does not mean the Linux desktop shell, installer, updater, or full experience is publicly supported.
  • Release gates cover Windows Authenticode, Mac Developer ID, notarization, and updater signatures; the README gives no equivalent Linux release gate.
  • Download: "Linux packages are internal build artifacts only and are not a supported public release target"
  • Download table: public platforms are Windows 10/11 64-bit and macOS
  • Run from source: "The sidecar uses Node core modules only"
git clone https://github.com/androoAGI/starnet.git
cd starnet
node sidecar/index.js
Not stated in the README：The README does not specify which Linux distributions, desktop environments, or architectures are used for internal builds.；It does not say whether sidecar-only Linux execution provides the same voice, notification, auto-update, and permission capabilities as the desktop build.
It depends I use StarNet on an M2 Mac and require the desktop app to run natively rather than through Rosetta 2; which release asset should I choose, and is macOS mature enough?
For: A developer using an Apple Silicon M1–M4 Mac who wants the macOS desktop build without Rosetta 2 overhead

It depends. The architecture choice is clear and native execution is available, but macOS has less real-world coverage than Windows, so it should not be treated as fully validated for every setup.

  • For Apple Silicon M1–M4, the README provides StarNet__aarch64.dmg and explicitly says not to use the x64 DMG because it runs through Rosetta 2.
  • Public releases support Windows and macOS, with Developer ID checks and Apple notarization required for macOS builds.
  • The README also says Windows is the most-tested target, macOS has less real-world coverage, and the project is an early release.
  • Linux is not a supported public release target; this does not affect an M2 install but shows that platform coverage is not uniform.
  • Download: "macOS — Apple Silicon (M1–M4)" and `StarNet__aarch64.dmg`
  • Apple Silicon note: "Avoid the x64 DMG on Apple Silicon"
  • Download: "Windows is the most-tested desktop target. macOS has less real-world coverage."
Not stated in the README：The README does not provide a compatibility matrix across macOS versions, M1–M4 chips, and voice, notification, or background features.；It does not state the exact regression-test coverage for each released version on specific macOS versions.
Yes I already have an on-disk OpenClaw or Hermes home and want to migrate persona, instructions, memory, and model without transferring API keys; does StarNet meet that migration constraint?
For: A developer already maintaining an OpenClaw or Hermes agent home who wants to retain persona, instructions, memory, and model configuration in a desktop workspace

Yes. The README explicitly supports importing an Agent from an on-disk OpenClaw or Hermes home while excluding API keys from the migration.

  • The importer reads the persona, instructions, memory, and model it finds in the existing home and mints a StarNet agent from them.
  • API keys never transfer; they must be entered again in the KEYS tab, matching the no-secret-copy requirement.
  • The result enters StarNet’s Agent workspace and local runtime, but the README does not promise one-to-one conversion of every OpenClaw or Hermes tool, schedule, or connector semantic.
  • The migrated provider still needs configuration through OpenRouter, supported OAuth sign-in, or Ollama.
  • Coming from OpenClaw or Hermes?: "it mints a StarNet agent from the persona, instructions, memory, and model it finds"
  • Coming from OpenClaw or Hermes?: "API keys never transfer — you re-enter those in the KEYS tab"
  • Features: "Bring your own models"
Not stated in the README：The README does not say whether OpenClaw or Hermes tools, cron jobs, MCP settings, and permissions are converted.；It does not describe partial recovery after import failure or whether an import can overwrite an existing StarNet Agent.
Yes I already have Node.js 18+, want to keep a vanilla JavaScript frontend, and need Rust/Tauri for the desktop shell; is StarNet's source structure suitable for extending?
For: An open-source contributor maintaining a Node.js 18+ sidecar who wants a vanilla JavaScript frontend and Rust/Tauri packaging for Windows and macOS

Yes. The project clearly separates the vanilla JavaScript frontend, Node sidecar, shared contracts, and Rust/Tauri shell; however, running the sidecar alone is not the same as building the desktop app.

  • frontend/ owns the station world and desktop UI, while sidecar/ owns providers, tools, persistence, budgets, and consent.
  • shared/ maintains cross-boundary event/schema contracts, and the frontend consumes real events over localhost HTTP/NDJSON and SSE.
  • The README says the sidecar uses only Node core modules and runs with Node.js 18+; Rust and Tauri prerequisites are needed for the desktop shell.
  • Desktop development supplies npm ci, npm run desktop:dev, and npm run desktop:build, keeping runtime work separate from packaging.
  • Run from source: "Requirements: Node.js 18+"
  • Architecture table: responsibilities for frontend, sidecar, shared, and src-tauri
  • Run from source: "The sidecar uses Node core modules only"
npm ci
npm run desktop:dev     # dev shell
npm run desktop:build   # build installers locally
Not stated in the README：The README does not describe version-compatibility rules for shared schemas or stability guarantees for third-party extension APIs.；It does not explain the diagnostic UI when sidecar-to-Tauri runtime communication fails after packaging.
Yes I need multiple Agents to run multi-step Recipes concurrently and continue through cron, Telegram, or Discord while I am away; can StarNet cover this workflow?
For: A developer who wants multiple Agents to run Recipes concurrently and manage Night Shift through cron, Telegram, or Discord

Yes, because the README explicitly covers concurrent Agents, Recipes, cron schedules, remote messaging channels, and Night Shift; execution boundaries still depend on configured permissions and stop conditions.

  • Each concurrent Agent receives its own workspace, transcript, memory, and bounded permissions rather than merely animating the UI.
  • Recipes launch proven multi-step tasks, while schedules put work on cron and expose visible output.
  • Telegram, Discord, Slack, Signal, and Matrix are listed integrations, and Task Briefs can ask clarification over connected channels.
  • Night Shift continues work while you are away, with away-actions logged and reviewable; the README does not promise success or automatic resolution of every coordination conflict.
  • Features: "Run several at once", "Recipes, skills, schedules", and "Night Shift"
  • Features: "Wire agents to Telegram, Discord, Slack, Signal, or Matrix"
  • What is real: "Multiple agents run concurrently with separate workspaces and bounded permissions"
git clone https://github.com/androoAGI/starnet.git
cd starnet
node sidecar/index.js
Not stated in the README：The README does not describe retry, deduplication, or failure-recovery behavior for cron tasks.；It does not specify permission models, event latency, or message-size limits for each external platform.
It depends I need Agent state and cost ledgers to remain local, but I still want OpenRouter or Anthropic for complex tasks; is StarNet suitable for my data boundary?
For: A developer who must keep agent state, transcripts, memory, and ledgers local while occasionally using OpenRouter, Anthropic, OpenAI, or Google cloud models

It depends: StarNet fits a boundary where runtime state stays local while selected model requests go to the cloud, but not an environment where task data must never leave the device.

  • The README states that agent state, transcripts, memory, and ledgers remain in the local StarNet workspace.
  • With OpenRouter, Anthropic, OpenAI, or Google, provider requests leave the machine; network tools and connectors expand the data path further.
  • Secrets are held by the sidecar or OS keychain rather than the frontend, reducing key exposure but not preventing task context from reaching a cloud model.
  • Fully local execution is possible through Ollama; the README warns that local models are smaller, slower, and rougher on long tasks.
  • Run from source: "station state, transcripts, memory, and ledgers stay in the local StarNet workspace"
  • Run free with a local model: "local models are smaller than the cloud ones, so expect slower and rougher work on long tasks"
  • Architecture: "Secrets are held by the sidecar / OS keychain, never in the frontend"
ollama pull llama3.1
Not stated in the README：The README does not specify which exact fields are sent with each cloud-provider request or each provider's retention policy.；It does not state whether cloud-context transmission can be restricted per Agent or per task.

✨ Highlights

  • Multiple AI agents run concurrently with separate workspaces and permissions
  • Model calls go through a local Node sidecar, with state and ledgers persisted on disk
  • Supports OpenRouter, Anthropic, OpenAI, Google, and Ollama
  • Windows 10/11 has more coverage, while macOS has less real-world coverage

🔧 Engineering

  • Maps capabilities, handoff lanes, and agent workflows onto a pixel-art space
  • Connects agents through Telegram, Discord, Slack, Signal, and Matrix
  • Runs ongoing work with Night Shift, cron schedules, and Recipes
  • Delivers results as real files in OUTBOX rather than chat scrollback

⚠️ Risks

  • Provider requests leave the machine; consult PRIVACY.md for the data map
  • Linux is only an internal build artifact and is not a supported public target
  • Ollama local models are smaller, making long tasks slower and rougher
  • MIT covers code only; the StarNet name, logo, and artwork are not licensed

👥 For who?

  • Developers who need multi-agent workflows on Windows 10/11
  • Local-first teams using Ollama, OpenRouter, or Anthropic
  • Users who need workspaces, permissions, transcripts, and spend records