convez.ai
AgenteProdutividadeAvançado
sbaruwal

AIWorkstation

sbaruwal/AIWorkstation

Canvas macOS nativo para orquestrar agentes de IA como cards de terminal isolados

Ver no GitHub
InicialPluginScore · de 0 a 100

Aplicativo nativo para macOS que oferece um canvas infinito para orquestrar múltiplos agentes de IA coding (Claude Code, Codex) como cards de terminal PTY reais, com isolamento via git worktree, nós de navegador e modo Focus. Totalmente local-first, sem backend.

Instalação

$npx convez-ai sbaruwal/AIWorkstation

1 comando no terminal: detecta o formato do repositório (marketplace ou plugin avulso) e instala via Claude Code. Requer Node 18+ e o Claude Code instalado.

Métricas

Estrelas
5
Forks
1
Acompanhando
0
Saúde
57%
Último commit
há 5 meses
Versão
v0.1.2
Issues abertas
0
Contribuidores
1

Casos de uso

  • Executar múltiplos agentes Claude Code/Codex em paralelo sem conflitos
  • Organizar e visualizar fluxo de trabalho de agentes em uma superfície única
  • Manter isolamento de projetos git com worktrees e evitar conflitos de árvore de trabalho

Veredito

Ferramenta sofisticada e bem-executada para devs que trabalham com múltiplos agentes. Swift puro em macOS soluciona um problema real (caos de abas), mas restringe público a usuários Apple. Excelente para quem adota AI coding agents seriamente.

README

A tradução para o português deste README ainda está na fila.


Table of contents


Why AIWorkstation?

Coding agents are powerful — until you run more than one. Then the workflow falls apart:

  • You juggle agents across separate terminal tabs and windows with no sense of what's where.
  • Two agents in the same repo trample each other's working tree.
  • You can't tell at a glance which agent is working, which is waiting on you, and which crashed — so finished work sits unnoticed.
  • Everything lives in someone else's cloud.

AIWorkstation turns that into a single spatial surface: every agent is a live card you can see, arrange, and talk to — with real process isolation and a status you can read from across the room.

What it is

A native Swift/SwiftUI app for macOS that puts real PTY-backed terminals on an infinite canvas. Each card runs your installed Claude Code or Codex CLI as a genuine child process — full TUI, colors, Ctrl-C, resize, copy/paste. Agents that share a repo are automatically dropped into isolated git worktrees so they never collide. It's local-first: layout and metadata live in a single JSON file, and there is no server.

What it isn't

  • Not an autopilot. You drive the agents — it orchestrates terminals, it doesn't make decisions for them.
  • Not a model runner. It doesn't host or fine-tune models; it drives the agent CLIs you already use.
  • Not a cloud service. No backend, no accounts, no telemetry.
  • It doesn't bundle the CLIs. Bring your own claude / codex; the app auto-detects them.

Features

🗺️ Infinite canvasPan, pinch-zoom, and a minimap. Cards are freely placed glass panels; the window is just a viewport.
🖥️ Real PTY terminalsEach card is a genuine pseudo-terminal (via SwiftTerm) running your Claude Code / Codex CLI.
🌿 Git worktree isolationA second agent on the same repo automatically gets its own branch + worktree — no clobbering.
🟢 Live agent statusA status dot derived from real PTY activity — Working, Waiting, Idle, Done, Error — with a pulse while busy.
🔔 NotificationsIn-app toasts + native macOS notifications when an agent finishes, crashes, a worktree is ready, or a CLI is missing.
⌨️ Command barType, don't click: claude fix the bug, codex, open github in browser, tell Harbor run the tests. Deterministic parsing with an on-device Apple Foundation Models fallback for fuzzy phrasing.
🔎 Focus ModeOne agent as a review cockpit: large terminal beside a live diff viewer, repo-state strip (branch · ahead/behind · changed), context files, and a command composer.
🌐 Browser nodesDrop a web view onto the canvas next to your agents — docs, a dashboard, a PR — addressable by name.
🧭 Multi-canvas workspacesSeveral named canvases in one window (⌘1–⌘9), each with its own agents, camera, and repo. Move a node between canvases without killing its session.
🎨 Themes & polishSwappable backdrops, System/Light/Dark appearance, push-to-talk voice dictation, a ⌘K palette, drag-and-drop folders & links.
🔒 Local-firstOne JSON file under Application Support. No server, no telemetry, no account.

Screenshots

Requirements

  • To build: Xcode 26 or later. The app imports Apple's FoundationModels, which only exists in the macOS 26 SDK — older Xcode fails with no such module 'FoundationModels'.

  • To run: macOS 15+ on an Apple Silicon Mac. On macOS 26+ with Apple Intelligence the on-device command parser kicks in; on macOS 15 the app runs fine on its deterministic parser.

  • The agent CLIs you want to drive, installed and on your PATH:

    The app auto-detects them through your login shell; you can also point it at a binary in Settings.

Install

Homebrew (recommended) — one command, and brew upgrade keeps it current:

brew install --cask sbaruwal/tap/aiworkstation

Or grab the .dmg directly:

  1. Download the latest AIWorkstation.dmg from Releases.
  2. Open it and drag AIWorkstation into Applications. It's signed with an Apple Developer ID and notarized by Apple, so it opens with no Gatekeeper warnings — no xattr dance, no right-click-Open.

Either way, bring your own claude / codex CLIs on your PATH (see Requirements) — the app auto-detects them on first launch. Or build it from source below.

Build from source

git clone https://github.com/sbaruwal/AIWorkstation.git
cd AIWorkstation
open AIWorkstation.xcodeproj      # then ⌘R in Xcode

…or from the command line:

xcodebuild -project AIWorkstation.xcodeproj \
           -scheme AIWorkstation \
           -configuration Debug build

Swift Package Manager resolves SwiftTerm automatically on first build — no manual dependency steps.

Quick start

  1. Launch the app. On first run it detects your claude / codex CLIs.
  2. In the command bar at the bottom, type claude refactor the auth module and hit return — an agent card spawns in your chosen repo and runs the task.
  3. Type codex to add a second agent. Same repo? It lands in its own git worktree automatically.
  4. Watch the status dots: green pulse = working, amber = waiting on you.
  5. Click a card's focus button (or type focus Harbor) to enter Focus Mode and review its diff.

Tip: press the ? in the command bar for the full grammar, and ⌘K for the command palette.

Command grammar

You typeWhat happens
claude refactor the auth moduleNew Claude agent in the chosen repo, task auto-run
codexNew Codex agent
open figma in browser · open github.comNew browser node
tell Harbor run the testsFollow-up message into the Harbor agent
focus HarborOpen the Harbor agent in Focus Mode
close HarborClose that node
Reef navigate to bsky.appPoint the Reef browser at a site
(just a task)Goes to your last-used agent

Node names (Harbor, Reef, Aspen…) are auto-assigned and case-insensitive; a 3-letter prefix is enough.

Architecture

flowchart TD
    U([You]) -->|"type a command / voice"| CB[Command bar]
    CB --> P{Parser}
    P -->|deterministic, instant| R[Route]
    P -->|ambiguous| FM[On-device<br/>Apple Foundation Models]
    FM --> R
    R -->|claude / codex| AG[Agent card<br/>real PTY]
    R -->|open …| BR[Browser node]
    R -->|tell / close Name| CTL[Control a live node]

    AG <-->|stdin / stdout| CLI[(Claude Code · Codex CLI)]
    AG -->|same repo?| WT[Git worktree<br/>branch-per-agent]
    AG -->|activity / exit| NOTE[Status dot + notifications]

    subgraph Canvas[Infinite canvas · multi-workspace]
      AG
      BR
    end

Type a command → it's parsed (instantly when it can be, on-device when it's fuzzy) → routed to spawn an agent, open a browser, or control an existing node by name. Agents run as real child processes; a second agent on the same repo is dropped into an isolated git worktree automatically. The canvas knows about panels, the terminal engine knows about processes, and an id-keyed registry is the boundary between them.

Keyboard shortcuts

ShortcutAction
⌘KCommand palette
⌘N · ⇧⌘NNew Claude / Codex agent
⌥⌘N · ⌘1–⌘9New canvas · switch to canvas N
⌘0Fit all to window
⇧⌘TTidy into a grid
focus button · EscEnter / exit Focus Mode (or focus <name> in the command bar)

Project layout

AIWorkstation/
├── App/            App entry, lifecycle, save-on-quit
├── Canvas/         Infinite canvas, camera, state, cards
├── Terminal/       SwiftTerm PTY controllers, live activity
├── Agent/          CLI detection, command parser, on-device smart-parse
├── Browser/        WKWebView browser nodes
├── Git/            Worktree management, diffs, repo state
├── Focus/          Focus Mode cockpit
├── Chrome/         Toolbar, sidebar, command bar, palette, settings, toasts
├── DesignSystem/   Theme tokens, canvas themes, appearance
├── Models/         Codable workspace / panel models
├── Persistence/    Local JSON store
└── Voice/          On-device push-to-talk dictation

Privacy

Everything runs locally. There is no backend and no analytics. The only network traffic is whatever your agent CLIs and browser nodes make on your behalf. Session layout and metadata are stored in a single JSON file under ~/Library/Application Support/AIWorkstation/. Live terminal sessions are never persisted — a restored card offers to relaunch rather than faking a dead process.

Contributing

Issues and pull requests are welcome. The codebase is plain SwiftUI + AppKit with no exotic dependencies — open it in Xcode and go. Please keep new code within the existing module boundaries and match the surrounding style.

License

MIT © 2026 Sujit Baruwal. Third-party components are listed in THIRD-PARTY-LICENSES.md.

Acknowledgments

  • SwiftTerm by Miguel de Icaza — the terminal engine behind the live PTY cards.
  • Built to drive Claude Code and Codex; this project is not affiliated with or endorsed by their respective owners.
Ver o original no GitHub

Bom para

Relacionados