skip to content
DanielZ Logo DanielZ Logo
Daniel Z
Table of Contents

Role

Founder and Developer - Native macOS App, Multi-Agent Runtime, and Product Design

Project Summary

Usta is a native macOS IDE for running an AI engineering team rather than a single assistant.

The project starts from a simple idea: real software work has roles, handoffs, blockers, reviews, and parallel tasks. Usta gives that workflow a local-first desktop interface. A PM agent reads the project brief, decides which specialists are needed, writes role-specific instructions, launches each role in its own live terminal session, and coordinates the work through a shared event bus.

The result is a workspace where frontend, backend, QA, security, design, DevOps, docs, mobile, data, or research agents can work in parallel while the user watches progress and unblocks the next bottleneck.

Product Screenshots

Usta workspace with specialist agents working in parallel

Usta workspace: one project, multiple specialist agents, separate live sessions, and shared coordination.

Usta PM proposal screen with generated team roles

PM proposal flow: Usta reads the project and proposes the team, stack, and role responsibilities before launching the workspace.

What Was Built

  • Native macOS app for managing multi-agent engineering workspaces.
  • PM auto-orchestration that turns a project idea into a dynamic specialist team.
  • Role-specific agent sessions with separate prompts, tools, context, and live terminal state.
  • Shared event bus for inter-agent coordination and handoff announcements.
  • Real PTY integration so each role can run in its own persistent terminal.
  • Idle watcher that detects when an agent finishes and publishes its status.
  • Bottleneck / next-action surface to show which role needs attention.
  • Pluggable model support for Anthropic, Gemini, and local Ollama workflows.
  • Keychain-backed API key storage so provider credentials are not written to normal project files.
  • MCP server support so external MCP-compatible clients can interact with Usta’s bus.
  • Skills system for reusable behaviours such as memory, TDD, diagnosis, and sharper clarification flows.
  • Live handoff graph that shows the team as a role-based DAG with state-coloured nodes, handoff edges, and event pulses.
  • Per-role token and cost dashboard reconstructed from local Claude and Codex session logs.
  • Session replay for scrubbing through a full run event-by-event, with self-contained HTML export for sharing.
  • Shareable team templates through .ustateam.yaml import/export and a starter template gallery.
  • Opt-in git worktree isolation so each role can work on its own usta/<role> branch before merge-back.
  • Opt-in cross-vendor review flow where one model family can implement and another can critique.
  • Zero-key demo mode for watching a full orchestrated run before adding provider credentials.
  • Public product website, visual guide, GitHub release flow, Homebrew cask, README, licensing, and trademark notes.

How It Works

The core workflow has four stages:

  1. Open a codebase or describe a new idea.
  2. The PM agent analyzes the project and proposes a purpose-built team.
  3. Usta launches the selected specialists as parallel sessions, then uses the event bus and watcher loop to coordinate handoffs.
  4. The user can inspect the live handoff graph, track per-role cost, replay the run, and export a shareable HTML trace.

Instead of forcing every task through one chat context, Usta separates responsibility across roles. A frontend agent can focus on UI, a backend agent can work on API concerns, QA can react when implementation lands, and a docs agent can capture the outcome. The user stays in the loop, but no longer has to manually copy every handoff between assistants.

Systems Used

  • Native app: SwiftUI and Swift 6 concurrency
  • Terminal sessions: SwiftTerm with real PTYs and persistent scrollback
  • Runtime daemon: Rust, tokio, and tonic gRPC over Unix Domain Socket
  • Local state: SQLite for events, scrollback, role state, and coordination metadata
  • Agent providers: Anthropic, Gemini, and Ollama
  • Security: macOS Keychain for API keys
  • Integration layer: MCP stdio server
  • Observability: live handoff graph, role states, event pulses, cost dashboard, and session replay
  • Team portability: .ustateam.yaml templates with replace-or-merge import
  • Git isolation: opt-in per-role worktrees and usta/<role> branches
  • Distribution: macOS DMG and ZIP release workflow through GitHub Releases, plus Homebrew cask install
  • Product site: static landing page and visual guide deployed on Vercel

Engineering Focus

Usta is designed around the parts of software work that single-assistant workflows usually hide:

  • Team composition: the right roles should depend on the project, not a fixed menu.
  • Handoffs: agents need a durable way to publish progress and trigger the next role.
  • Terminal reality: each role should have a live shell, not just abstract tool calls.
  • Local control: user code, credentials, and context should stay on the user’s machine wherever possible.
  • Recoverability: scrollback, role state, and event history should survive daemon restarts.
  • Observability: users should be able to see who is working, who is blocked, what each handoff means, and what the run costs.
  • Shareability: team definitions and run history should be easy to export without turning the desktop app into a cloud product.

July 2026 Update - v0.2.0

Usta v0.2.0 - see the team think moves the project from a first public macOS release into a more observable and shareable multi-agent engineering environment.

The main update is visibility. Usta now includes a live handoff graph, showing roles as an animated DAG with state-coloured nodes, handoff edges, and event pulses. This makes the orchestration layer easier to understand while the team is working.

The release also adds a per-role cost dashboard, session replay, and self-contained HTML export. A full agent run can now be reviewed after the fact, scrubbed event-by-event, and shared as a standalone replay instead of being trapped inside the local app session.

Team setup is more portable too. Usta can export and import complete teams as .ustateam.yaml templates, with replace-or-merge behaviour and a starter gallery for reusable role definitions. For code changes, the new opt-in worktree mode gives each specialist its own isolated usta/<role> branch, reducing file conflicts between parallel agents and supporting one-click merge-back.

The update also introduces opt-in cross-vendor review, where a role can ship work and another model family can critique it with a ready-to-send review prompt. A zero-key demo mode now lets users watch a full orchestrated team run before adding any API key.

Performance and release polish were improved as well: CLIs launch lazily, sleeping panes detach from the renderer, two SwiftUI grid-related freezes were fixed with a deterministic custom layout, an in-app update banner checks GitHub releases daily, and installation is now available through both GitHub release assets and Homebrew.

Current Status

Usta has a public macOS release available through GitHub Releases and Homebrew. As of v0.2.0, the focus is on making multi-agent engineering observable, replayable, and easier to share: live handoff graph, per-role cost dashboard, session replay, team templates, worktree isolation, cross-vendor review, and a zero-key demo.

Roadmap

  • Expand beyond macOS with Linux and Windows support.
  • Strengthen fully local workflows with Ollama-first defaults.
  • Grow the team-template gallery into a community role marketplace for sharing specialist role definitions.
  • Add cloud sync for the event log where users want cross-machine continuity.
  • Explore a VS Code extension as an alternative interface for the same coordination model.
  • Extend cost, replay, and review workflows for larger multi-agent projects.

Skills

  • Native macOS App Development
  • SwiftUI
  • Rust Runtime Engineering
  • Multi-Agent System Design
  • MCP Integration
  • LLM Tooling
  • Product Design
  • Developer Experience
  • Performance Engineering
  • CI and Release Engineering