Skip to content
/
Tier B A20 OS-level substrate

Sparo OS

sparo-os · GCWing/Sparo-Agentic-OS · ★ 6 · last commit 2026-05-26

Cross-platform Tauri desktop application that acts as an Agentic OS runtime — hosting continuous AI task execution, workspace management, and dynamically-generated Live Apps across Code, Cowork, and Design built-in apps with mobile remote control.

Best whenAI-as-OS means a unified entry point (single conversation box) hiding all workspace/session/toolchain complexity, with dynamically generated persistent UI co…
Skip ifTauri core code depending on Tauri-specific types (platform-agnostic core required)
vs seeds
kiro(Archetype 5, closed IDE with proprietary runtime) but open-source Tauri desktop app rather than VS Code fork. Unique el…
Primitive shape
No installable primitives
00

Summary

sparo-os — Sparo OS (GCWing/Sparo-Agentic-OS)

Sparo OS is a Tauri-based cross-platform desktop application (Rust + React/TypeScript) that implements an "Agentic OS" concept for the AI era — a unified operation layer for continuous AI task execution, workspace management, and intelligent app hosting. Unlike behavioral frameworks that add instructions to existing AI tools, Sparo OS is itself the agent runtime interface: users run Sparo OS, open intelligent apps (Code, Cowork, Design), and Sparo OS manages sessions, workspaces, and context continuity. The three app types (Agent App, Live App, Bridge App) map to different interaction modalities. The Dev Kit supports external Skills, MCP (including MCP Apps), and custom Sub Agents. Platform support extends beyond desktop to mobile control via browser, Telegram, Feishu, and WeChat. Built with Tauri, it is cross-platform (Windows, macOS, Linux). Version v0.1.0 with 6 GitHub stars.

Compared to the seeds, Sparo OS is closest to kiro (Archetype 5 — closed IDE with proprietary primitives) but as an open-source Tauri desktop app rather than a VS Code fork. The key delta from kiro is the mobile-remote-control capability and the "Live App" concept (dynamically generated interfaces that persist and evolve), which has no parallel in any seed.

01

Overview

Overview — Sparo OS (GCWing/Sparo-Agentic-OS)

Origin

Sparo OS is an open-source project by GCWing, described as "a spare-time exploration and research effort toward next-generation human-machine collaboration." Core: GCWing/BitFun. Built with Tauri; "more than 99% of this project was built with Vibe Coding."

Philosophy

From README:

"Sparo OS is an agentic OS built for the AI era. It hosts the scheduling and continuous runtime of all kinds of intelligent applications, with desktop support across Windows, macOS, and Linux."

"You only need to state what you want. Whether you start directly from the desktop app or direct it remotely through your phone or bots, Sparo OS organizes tasks, carries context forward, and keeps AI working continuously in the background, gradually adapting to your personal workflow."

Design Philosophy

Organized around Agentic OS + Intelligent Apps:

  • Agentic OS: unified operation layer for tasks, workspaces, sessions, toolchains, and remote entry points — AI becomes a continuously running work system rather than one-off replies
  • Intelligent Apps (Agent App / Live App / Bridge App): first-class application forms with different capability shapes
  • Dev Kit: built for intelligent app development — Skills, Tools, MCP, Sub Agents as building blocks
  • Unified scheduling and unified entry point: users enter specific apps/tasks/workflows inside one system

Key Innovation: Live Apps

Live Apps are "dynamically generated by Agents with the interface and capabilities best suited to the user's workflow. They have persistent identity and state, and can continue evolving." This concept — AI-generated persistent UI components — has no parallel in the seed corpus.

02

Architecture

Architecture — Sparo OS (GCWing/Sparo-Agentic-OS)

Distribution

  • Type: Desktop application (Tauri binary)
  • Install (binary): Download from GitHub Releases
  • Build from source:
    pnpm install
pnpm run desktop:dev    # development
pnpm run desktop:build  # production build
  • Prerequisites: Node.js (LTS), pnpm, Rust toolchain, Tauri prerequisites

Tech Stack

  • Desktop shell: Tauri 2 (Rust backend + WebView)
  • UI: React 18 + TypeScript
  • Build: Vite + pnpm
  • Testing: Playwright E2E

Directory Structure

Sparo-Agentic-OS/
├── src/
│   ├── apps/
│   │   └── desktop/        # Tauri 2 desktop shell, commands, capabilities
│   ├── crates/
│   │   ├── core/           # Platform-agnostic business logic, agent runtime, services
│   │   │   └── src/
│   │   │       ├── agentic/  # agents, prompts, sessions, dialog turns, model rounds, tool execution
│   │   │       ├── service/  # workspace, config, filesystem, terminal, git
│   │   │       └── infrastructure/ # AI adapters, logging, storage, debug
│   │   ├── events/         # Platform-agnostic event contracts
│   │   ├── transport/      # Core/events to app surface adapters
│   │   └── api-layer/      # Shared request/response handlers
│   └── web-ui/             # React 18 + TypeScript UI
│       ├── app/            # Shell and desktop panels
│       ├── flow_chat/      # Chat UI, tool cards, streaming/tool events
│       ├── tools/          # Editor, terminal, git, mermaid, design canvas
│       ├── infrastructure/ # Theme, i18n, config, API adapters
│       ├── design-system/  # Reusable UI APIs, visual contracts
│       └── locales/        # Translations (zh-CN, en)
├── bundles/                # Packaged app bundles
├── packages/               # Shared packages
├── installer/              # Installer tooling
├── AGENTS.md               # AI agent instructions
└── scripts/

Platform Support

  • Desktop: Windows, macOS, Linux (via Tauri)
  • Mobile remote control: Phone browser, Telegram, Feishu, WeChat

Required Runtime

  • Tauri desktop binary (pre-built or compiled)
  • AI model API key (configured in app settings)
03

Components

Components — Sparo OS (GCWing/Sparo-Agentic-OS)

Built-in Intelligent Apps

App Category Description
Code Software development Agentic, Plan, Debug, and Review workflows
Cowork Office collaboration Requirements organization, content drafting, knowledge work
Design Design exploration HTML prototypes, visual artifacts, design collaboration

App Types

Type Description
Agent App Autonomous execution-oriented — composed of one or more Agents, conversation and task flow as main interaction model
Live App Dynamically generated by Agents — persistent identity and state, continues evolving, best-suited interface generated per user workflow
Bridge App Adds Agent layer on top of existing GUI software — legacy software integration

Dev Kit Components

  • Skills: External skill packs (AgentSkills format compatible?)
  • MCP: Model Context Protocol servers (including MCP Apps)
  • Sub Agents: Custom sub-agent definitions
  • Tools: Built-in scene-specific tools

Core Architecture (src/crates/core)

  • agentic/ — agents, prompts, sessions, dialog turns, model rounds, tool execution
  • service/ — workspace, config, filesystem, terminal, git
  • infrastructure/ — AI adapters, app paths, logging, storage, debug ingest, events

UI Components (src/web-ui)

  • flow_chat/ — chat UI, tool cards, streaming/tool event presentation
  • tools/ — editor, terminal, git integration, Mermaid diagram rendering, design canvas
  • design-system/ — reusable UI APIs, visual contracts, AI-facing UI rules

Remote Access

  • Mobile browser control
  • Telegram bot integration
  • Feishu (Lark) integration
  • WeChat integration
05

Prompts

Prompts — Sparo OS (GCWing/Sparo-Agentic-OS)

Note

Sparo OS is a desktop application and agent runtime, not a prompt framework. Prompt files are embedded in the application source (src/crates/core/src/agentic/) rather than exposed as editable markdown files. The AGENTS.md provides development instructions for contributors building the Sparo OS codebase itself, not behavioral prompts for end-user AI agents.

Excerpt 1: AGENTS.md — Platform Boundary Rule

Source: AGENTS.md Technique: Constraint-first development guidance to maintain platform abstraction boundaries

## Critical Rules

### Platform Boundaries

Core code must stay platform agnostic.

- In `src/crates/core`, do not depend on Tauri types such as `tauri::AppHandle`.

Excerpt 2: README — Design Philosophy Statement

Source: README.md Technique: Vision framing for the "AI as OS" concept

## Design Philosophy

Sparo OS is organized around **Agentic OS + Intelligent Apps**:

- **Agentic OS**: the unified operation layer that carries tasks, workspaces, sessions, 
  toolchains, and remote entry points, turning AI from one-off replies into a continuously 
  running work system.
- **Intelligent Apps (Agent App / Live App / Bridge App)**: first-class application forms 
  that carry different capability shapes.
09

Uniqueness

Uniqueness — Sparo OS (GCWing/Sparo-Agentic-OS)

Differs From Seeds

Sparo OS is closest to kiro (Archetype 5 — closed IDE with proprietary primitives) in being a full application environment with its own agent runtime, rather than an add-on to an existing AI tool. The key deltas from kiro: (1) open-source (MIT) vs kiro's proprietary/paid model; (2) Tauri desktop app (cross-platform native) vs VS Code fork; (3) mobile remote control (Telegram, Feishu, WeChat, phone browser) — no other framework in the corpus enables mobile-driven desktop agent sessions; (4) Live App concept — AI-generated persistent UI components with evolving state, a concept with no parallel in any seed; (5) multi-surface intelligent apps (Code + Cowork + Design) rather than coding-only focus; (6) vibe-coded codebase (99%+ AI-generated) as an explicit design statement.

Positioning

Sparo OS explores "AI as OS" in the fullest sense — not a framework layered on top of Claude Code or another tool, but a standalone runtime environment where the AI continuously manages tasks, workspaces, and app state. The unified entry point (single conversation box hiding underlying complexity) and mobile-remote pattern suggest a consumer-facing vision beyond developer tooling.

Observable Failure Modes

  1. v0.1.0 maturity: Early version (6 stars, spare-time project) — rough edges expected
  2. Mobile integration complexity: Telegram/Feishu/WeChat bridges require configuration and maintenance
  3. "Vibe coded" codebase: 99%+ AI-generated code may have structural inconsistencies
  4. No external skill/plugin ecosystem yet: Dev Kit documented but ecosystem is nascent
  5. Low portability: Agents only work within Sparo OS, cannot be used with Claude Code, Cursor, etc.
04

Workflow

Workflow — Sparo OS (GCWing/Sparo-Agentic-OS)

Primary User Flow

  1. Download and install Sparo OS desktop app
  2. Configure AI model (API key in settings)
  3. Open an intelligent app (Code, Cowork, Design) or create a custom Agent App
  4. State intent in the conversation box — "almost zero barrier to getting started"
  5. Sparo OS organizes tasks, carries context forward, keeps AI working continuously

Code App Workflow

Built around four workflows:

  • Agentic: autonomous execution
  • Plan: planning before implementation
  • Debug: troubleshooting
  • Review: code review

Remote Workflow

  • User opens phone browser or messaging app (Telegram, Feishu, WeChat)
  • Directs Sparo OS running on desktop remotely
  • Sparo OS continues work in background

Phase-to-Artifact Map

Phase Artifact
Task creation Task in Sparo OS workspace
Agentic execution Code, documents, or design artifacts
Live App generation Persistent generated UI component
Session persistence Context carried forward to next session

Approval Gates

None documented explicitly — the design philosophy emphasizes "almost zero barrier to getting started" and direct intent statement.

06

Memory Context

Memory & Context — Sparo OS (GCWing/Sparo-Agentic-OS)

Session Continuity

Sparo OS explicitly handles context continuity: "Sparo OS organizes tasks, carries context forward, and keeps AI working continuously in the background." The exact mechanism is embedded in the application runtime (src/crates/core/src/agentic/) rather than documented as user-facing files.

Workspace Model

Each intelligent app runs in a workspace managed by Sparo OS. The service/workspace crate handles workspace state management.

Live App Persistence

Live Apps have "persistent identity and state, and can continue evolving" — this is the most distinct memory feature: AI-generated UI components that persist across sessions.

Storage Layer

infrastructure/storage crate — exact storage backend (SQLite, file-based, etc.) not documented in public README.

Cross-Session Handoff

Yes — described as a key feature: "seamless AI-to-AI continuity" implied by the continuous operation model.

07

Orchestration

Orchestration — Sparo OS (GCWing/Sparo-Agentic-OS)

Multi-Agent Support

Yes — Sub Agents are supported as a first-class Dev Kit component. "Agent Apps" are "composed of one or more Agents."

Orchestration Pattern

Unknown (application runtime, not externally documented pattern).

Isolation Mechanism

Application-level workspace isolation (Tauri window per app, workspace service per session).

Multi-Model Support

Yes — AI model is configurable in settings; multi-provider support implied.

Execution Mode

Background daemon (continuous — keeps AI working in background).

Cross-Tool Portability

Low — Sparo OS is the runtime; agents run within Sparo OS, not alongside other AI tools.

Remote Control

Mobile browser + Telegram/Feishu/WeChat as remote entry points — unique multi-surface access pattern.

08

Ui Cli Surface

UI & CLI Surface — Sparo OS (GCWing/Sparo-Agentic-OS)

Desktop Application

Yes — Tauri 2 + React desktop app (primary product surface).

  • Tech stack: Tauri 2 (Rust) + React 18 + TypeScript + Vite
  • Features:
    • Unified conversation box for all apps
    • Chat with tool cards and streaming/tool event presentation
    • Integrated editor, terminal, Git, Mermaid diagrams, design canvas
    • Apps hub (Code, Cowork, Design + user-created apps)
    • Workspace management
  • Playwright E2E tests for UI quality

Mobile Remote Control

  • Phone browser access (web UI served from desktop)
  • Telegram bot integration
  • Feishu (Lark) integration
  • WeChat integration

Design System

src/web-ui/src/design-system/ — reusable UI APIs, visual contracts, preview coverage, AI-facing UI rules. Published as a preview app (pnpm run preview:design-system).

CLI Binary

None — Sparo OS is a GUI application.

Observability

  • src/crates/core/src/infrastructure/debug — debug ingest
  • src/crates/core/src/infrastructure/logging — structured logging
  • No external audit log documented

Related frameworks

same archetype · same primary tool · same memory type

Personal AI Infrastructure (PAI) ★ 14k
A20 OS-level substrate

Life Operating System that drives every task as a current→ideal-state transition through a 7-phase Deutsch-epistemology…

osModa ★ 99
A20 OS-level substrate

AI-native NixOS operating system where 10 Rust daemons expose 91 structured MCP tools giving the agent root-level typed access to…

Superpowers ★ 207k
A1 Skills-only

Enforces spec-first, TDD, and subagent-reviewed development as mandatory automatic workflows rather than optional practices.

Spec Kit ★ 106k
A2 Mirror cmd+skill

Turns a natural-language feature description into a complete, versioned, AI-executable specification pipeline installable for 30+…

OpenSpec ★ 51k
A2 Mirror cmd+skill

Adds a lightweight spec layer so AI coding assistants and humans agree on what to build before any code is written.

BMAD-METHOD ★ 48k
A4 Markdown scaffold

Provides a full agile delivery lifecycle with named expert-persona AI collaborators that elicit the human's best thinking rather…