Team-X

v3.5.0 is about trust: every setting now does what its label says.

• Enforced privacy tiers. Every model call, embedding and external runtime is checked against Settings → Privacy. A provider above the tier is refused with a reason and is never silently swapped.
• Copilot grounded in your company's knowledge, with long-term memory and a knowledge graph that survive restarts.
• The Models tab. Run GGUF models locally, browse Hugging Face, and connect LAN model servers.
• A palette that understands commands, plus meeting minutes that file action items, a Hire dialog with all 55 roles, and a per-company Proactive Mode that works.
• A Linux AppImage with no FUSE 2 requirement.

Full release notes: What's New · installers: v3.5.0 release.

• 57 curated F10 roles: 55 user roles across 6 hierarchy levels (Officer, Senior Management, Management, Supervisor, Lead, IC) plus 2 hidden system roles, hand-written role specifications, not generic templates
• Multi-company workspace: run multiple AI organizations side-by-side, each with its own employees, goals, and settings
• Org chart editor: drag-to-rearrange reporting lines, promote, fire, set managers, edit employee profiles, visualize the full hierarchy with color-coded levels
• Hire dialog: searchable role catalog with level filter chips, one-click hiring from the curated pack

• Mission Control dashboard: five subviews: Mission Control (live ops stats, queues, runs, runtime heartbeats), Timeline (event feed), Stream (raw LLM output), Floor (employee activity grid), Commands (palette history with intent labels)
• Annunciator rail: five real signal lamps (QUE / GGUF / BUDG / APPR / MTG) with a master-caution acknowledge ritual: blinking means unacknowledged, click to ack, click again to teleport to the source view
• Goals and projects: set company-level goals with auto-derived progress meters, create projects with lead / priority / target date, track everything on a status kanban
• Schedule and calendar: a team week view plus agenda: manual tasks and reminders alongside automatic ticket due dates, project targets, goal targets, overdue counters, and assigned agent wakeups
• Ticket kanban: 4-column board (Open, In Progress, Blocked, Done) with drag-to-move, a detail rail for participants / attachments / discussion / ticket memory, and automatic agent assignment
• One-click meetings: call an all-hands with selected attendees, interject mid-meeting, auto-generated minutes with action item extraction
• Real-time telemetry: company stats, daily usage charts, per-employee breakdown, cost analysis by provider and model with date range filtering plus Work / Agentic / Copilot run-kind filters

Team-X's interface is a purpose-built hardware design language, Command Console / Carbon Pro, modeled on professional broadcast and DJ gear rather than generic SaaS chrome:

• Dual-shift theming: Night Ops (brushed black aluminum, default) and Day Shift (silver anodized), switchable from the top bar. Displays stay void-black in both shifts, exactly like real silver hardware keeps black LCDs
• Stencil word-lamps: status is a word in a lamp tile (GO / HOLD / NO-GO / STBY / EXEC), never an ambiguous icon or colored dot
• Functional instrumentation: LCD readouts and VU meters are data-bound only (queue pressure, goal progress, workforce utilization); nothing blinks or glows for decoration
• The dual-form red rule: steady red means LIVE / armed / command authority; blinking red is a question that demands an answer

The same dashboard in Day Shift: silver chassis, displays stay dark.

A full operator console for governed autonomous work (the Autonomy tab, 10 subviews):

• Doctor: pre-flight health workflow: DB integrity, recovery readiness, runtime posture, secrets, provider/MCP health, budget blockers
• Benchmarks: replay deterministic autonomy scenarios and inspect pass rates, recovery timing, duplicate-work prevention, and spend
• Runtime profiles & operations: bind execution profiles (internal / local / external agents) to employees; watch live heartbeats and ticket checkouts
• Routines: recurring operating loops that materialize into explicit, auditable ticket runs
• Budgets: spend governance with warnings, hard caps, escalation thresholds, and a full ledger across company / employee / runtime / routine scopes
• Approvals: one unified decision inbox for authority, planner, budget, and routine decisions
• Artifacts, Memory, Access, Improve: runtime evidence, thread digests + resumable checkpoints, operator/sharing posture, and a self-improvement loop that opens deduped correction tickets from recent failure signals

• 9 LLM providers: Ollama (local), Anthropic, OpenAI, Google Gemini, Groq, OpenRouter, Together AI, Fireworks AI, plus any OpenAI-compatible endpoint
• Privacy tiers: Local, Open-Source Cloud, Proprietary Cloud; filter which providers your agents can use
• Adaptive runtime strategy: Auto, Hybrid, Always-On, or Lean mode based on a live hardware profile (CPU cores, RAM, GPU, VRAM shown in Settings). GPU detection is native on all three platforms: wmic on Windows, system_profiler on macOS (Apple Silicon reports its unified-memory GPU budget), and nvidia-smi with an lspci fallback on Linux
• MCP tool calling: agents use Model Context Protocol tools via a singleton host with connection pooling and tools_allowed/tools_denied enforcement
• Skills & authority: install skills from a local folder or GitHub URL, import MCP servers from templates or manual config, and govern everything through authority grants and per-employee permissions
• Employee-to-employee messaging: agents communicate with colleagues via built-in tools, forming collaborative workflows
• Local GGUF models: a Models tab with four panels: Library (add a .gguf file or watch a folder, rescan or stop watching it, per-model system prompt / chat template / advanced tuning, load and unload), Discover (search Hugging Face, browse a repo's files, queue resumable downloads that survive a pause or a quit), Endpoints (LM Studio / Ollama / llama-server / KoboldCPP / vLLM on your LAN, validated as local-network only and probed for reachability), and Runtime (GPU inventory across CUDA / ROCm / Vulkan / Metal / CPU, active backend, LRU pool capacity, bundled llama.cpp build). Per-model benchmarks record prompt-eval and generation throughput measured from llama-server's own timings, never an estimate. A GGUF model is not yet an agent provider; Ollama remains the local path for employees

• RAG-grounded agent turns: every agent prompt is augmented with retrieved context from messages and vault files via the @team-x/intelligence package (embeddings stored as BLOBs in SQLite and ranked in-process by cosine similarity: an exact per-company scan, or an IVF approximate index once a company holds 4,096 or more vectors; token-aware chunking with overlap, cosine-threshold gating, SHA256-dedup attribution blocks)
• Enhanced AI subsystem: semantic chunking for the RAG index (splits on headings, paragraphs and code fences instead of a blind character window), query expansion, long-term memory with LLM fact extraction, a cross-thread knowledge graph (both persisted in SQLite), and sampled span tracing. It is active whenever RAG is enabled with an embedding provider, grounds Copilot answers through the search_company_knowledge tool, and remembers completed Copilot exchanges. Each is a toggle in Settings → Enhanced AI; the Copilot's own model writes the answer from that grounding and cites its sources
• Natural-language command palette (Cmd+K): 14 structured intents (hire / fire / promote / assign / create / close / reopen / project / goal / meeting / status / navigation / vault search) plus a complex_request fallback that hands off to the agentic loop. LLM-backed classifier with JSON-output retry, fuzzy entity resolution, FTS5 ticket lookup, destructive-action confirmation gate, last-20 command history
• Agentic loop for complex questions: ask free-form questions like "why is the frontend team behind schedule?" and get a grounded multi-paragraph answer citing specific tickets, employees, and events. Runs a ReAct-style loop on a hidden system-agent pseudo-employee, dispatches six read-only query tools, and terminates under hard step / token / wall-clock budgets (defaults 8 / 8000 / 120s, configurable in Settings → Agentic Loop)
• Live step log + persisted thread: the palette streams each loop step as a labeled card (plan → tool call → tool result → answer) with provider and token footer; full transcripts persist for later reference, and every run can be canceled mid-flight
• Task Planner (write-side): Management-and-above agents can decompose projects into tickets, delegate subtasks with deterministic workload scoring, and review deliverables. Level-gated tool injection, an amber confirmation gate before any ticket is created, and four clamped guardrail settings in Settings → Task Planner
• Copilot (proactive analyst): a hidden system-copilot employee analyzes the company on a 5-minute cadence (plus event triggers) and surfaces insights across five categories (operational / cost / org / workflow / anomaly) with three severities. Deterministic dedup, dismissal-feedback weight tuning (advisory by default, self-tuning opt-in), and zero phone-home: analysis runs on whatever provider you've configured
• Copilot UI: right-side sidebar (Cmd+Shift+K, Sparkles toolbar button, or dashboard widget) with severity-sorted insight feed, category/severity filters, CSV/JSON export, action-suggestion buttons through the gated command pipeline, and an Ask-Copilot box that routes free-form questions through the agentic harness

• File vault + agent-created deliverables: filesystem-backed blob storage with SHA256 integrity verification, FTS5 full-text search, ticket attachments, and employee-generated txt / md / csv / json / html / docx / xlsx / pptx outputs
• One-click backup/restore: full SQLite + vault archive with manifest validation
• Append-only audit log: filterable event timeline with summary cards, actor search, date range picker, and CSV/JSON export
• Workspace portability: export a company as a template package, preview and import packages, share with a reviewed posture
• Paperclip Import: preview a Paperclip export folder (agents, runtimes, tickets, skills, unsupported adapters, missing secrets), save it as a .teamx-package.json, and review & import it through Portability; nothing is created until Portability commits it
• Private Operator Access: a read-only decision record of what a non-workstation device would be allowed to do in a workspace (Localhost / Tailscale / Hosted bridge), with every refusal and its reason; nothing opens a listener
• In-app User Guide: role-based onboarding (owner / operator / builder) with 25 sections, progress tracking, and deep links that jump straight into the referenced view or settings section
• Cross-platform installers: Windows (NSIS), macOS (DMG), Linux (AppImage + .deb) via electron-builder
• User-triggered updates: check for new versions from GitHub Releases on demand (zero phone-home)

Grab the latest release for your platform from GitHub Releases:

Linux AppImage note: v3.5.0 and later embed AppImage's static runtime, so the AppImage starts on a stock Ubuntu 22.04 / 24.04 desktop with no extra packages (#16). v3.4.0 and earlier need FUSE 2 (libfuse2; libfuse2t64 on Ubuntu 24.04; fuse-libs on Fedora); if one of those won't start, install that package or run ./Team-X-x.x.x-x86_64.AppImage --appimage-extract-and-run. The .deb never needs FUSE and resolves its own dependencies (sudo apt install ./Team-X-x.x.x-amd64.deb).

Unsigned builds: the installers are not code-signed yet, so Windows and macOS warn before the first run. Check a download against the release's SHA256SUMS.txt; from v3.5.0 you can also verify its build provenance with gh attestation verify <file> --repo Git-Rocky-Stack/Team-X.

# Prerequisites: Node.js 22.13+ (repo pins 22.22.2 via .nvmrc), pnpm 9+
git clone https://github.com/Git-Rocky-Stack/Team-X.git
cd Team-X
pnpm install
pnpm dev

Team-X works fully offline with local models. Install Ollama, then:

ollama serve
ollama pull llama3.1:8b

Launch Team-X. Its first launch adds an enabled Ollama (Local) provider at http://localhost:11434, so a running Ollama needs no further setup.

Add any supported provider in Settings > AI Providers: enter your API key, test the connection, and toggle it on. Your keys are stored in the OS keychain (never in config files).

Team-X/
  apps/desktop/             Electron app
    src/main/               Main process (Node.js + TypeScript)
      db/                   SQLite + Drizzle ORM (38 migrations)
      ipc/                  Typed IPC handlers (236 registrations / 229 bridge methods)
      orchestrator/         Agent scheduler + event bus
      services/             Vault, backup, MCP host, providers, updater,
                            rag-indexer, command-service, agentic-loop,
                            copilot-analyzer, routine-service, budgets,
                            local-gguf (library / pool / runtime / endpoints /
                            hf-downloads / benchmarks), heartbeat
    src/preload/            Context-isolated bridge (TeamXApi)
    src/renderer/           React 19 + Tailwind + shadcn/ui on the
                            Command Console design system (DESIGN.md)
      components/console/   Faceplate, LampTile, LcdWell, MetricTile,
                            VuMeter, AnnunciatorRail, ShiftToggle, Tag
      features/             audit, autonomy, chat, command, copilot,
                            dashboard, hire, meetings, memory, models,
                            orgchart, projects, settings, telemetry, tickets,
                            user-guide, vault, workspace
      hooks/                React Query hooks
      store/                Zustand app store
    e2e/                    20 Playwright specs / 29 cases
  packages/
    shared-types/           IPC contract types, event types, entities
    role-schema/            Role-spec parser + renderer + pack signing
    provider-router/        LLM provider registry + streaming adapters
    telemetry-core/         Cost calculation utilities
    intelligence/           RAG (chunker, embedding, retriever),
                            NLU (classifier, entity resolver, slot filler),
                            agentic loop (ReAct scheduler, tool registry)
    local-gguf-runtime/     GPU probe, llama.cpp lifecycle, LRU pool,
                            GGUF parser, folder watcher, auto-tune
  role-packs/
    strategia-official/
      roles/                57 curated F10 roles across user + system levels
      roles/system/         Hidden system-agent + system-copilot role cards

• Renderer is a pure view. No direct LLM or MCP calls. Every interaction crosses the typed IPC bridge.
• Orchestrator is the only scheduler. Pause semantics (e.g., during meetings) are race-free because nothing dispatches without the orchestrator's consent.
• MCP Host is a singleton. One pool of connections shared across all agents, with no N-client sprawl.
• Storage is SQLite + filesystem. Metadata in SQLite, blobs on disk, SHA256 integrity. File blobs never go in the database.
• Provider resolution is the single LLM gateway. The provider factory and runtime-profile resolver enforce the privacy tier on every run; the provider router carries concurrency caps and cost tracking.
• Events table is append-only. Source of truth for the real-time dashboard and audit log.
• The design system is law. Every surface follows DESIGN.md (Command Console / Carbon Pro): four-layer hardware depth, dual-shift theming, displays-stay-dark, data-bound instrumentation only.
• Zero phone-home. Ever. No telemetry, no analytics, no auto-update checks. Updates are explicitly user-triggered.
• Secrets live in the OS keychain via keytar. Never in config files.

Team-X includes comprehensive documentation across 142 files:

• Quick Start Guide: 15-minute setup walkthrough for new users
• Getting Started: first company, first hire, first ticket
• Comprehensive User Guide: complete product documentation
• In-app User Guide: role-based onboarding with progress tracking, built into the app (left rail → User Guide)

• FAQ: frequently asked questions
• Troubleshooting: common issues and solutions
• Glossary: term reference
• Keyboard Shortcuts: the real shortcut surface
• Command Palette Reference: every palette command (Team-X has no command-line tool)

• Product Development Lifecycle: complete product workflow
• Cost Optimization Playbook: budget management
• Failure Recovery Workflows: Copilot-guided recovery
• Cross-Functional Collaboration: team coordination
• Autonomous Routine Governance: routine automation
• Multi-Workspace Operations: multi-client workflows
• Shift Handoff Playbook: operator transitions

• Templates: handoff documents, meeting agendas, ticket templates, routine templates

• Developer Reference: architecture, MCP server development, role pack format, internal IPC surface
• Integration Guide: providers, MCP servers, and extension points
• Dependency Upgrade Program: the audit gate, accepted exceptions, and the order of the remaining major upgrades
• Release Signing: signing credentials, the signature gate, install smoke tests, provenance, and dry runs
• Branch Governance: the main and release-tag rulesets, the review wall, break-glass, and signed tags
• Architecture · API Endpoints · Database Schema · Design System

• Migration Guide: switching from other tools
• Accessibility Guide: WCAG 2.1 compliance documentation

• llms.txt: AI-optimized documentation index for LLM consumption
• long-llms.txt: extended AI reference with comprehensive details

# Install dependencies (runs electron-rebuild postinstall)
pnpm install

# Start dev server with HMR
pnpm dev

# Run unit tests
pnpm test

# Run E2E tests (builds first)
pnpm -F @team-x/desktop test:e2e

# Typecheck all workspaces
pnpm typecheck

# Lint + format
pnpm lint
pnpm format

pnpm dist          # Current platform
pnpm dist:win      # Windows NSIS (x64 + arm64)
pnpm dist:mac      # macOS DMG (x64 + arm64)
pnpm dist:linux    # Linux AppImage + .deb (x64)

pnpm -F @team-x/desktop exec drizzle-kit generate --name <snake_case_name>

See CONTRIBUTING.md for the full development guide.

Team-X ships with 4,718 unit tests across 376 files and 20 Playwright E2E specs (29 cases):

All E2E specs run against a canned test-mode provider: no Ollama, no API keys, no network.

pnpm test              # Unit tests
pnpm -F @team-x/desktop test:e2e   # E2E (full build + Playwright)

Team-X is built with a privacy-first posture:

• Local-first by default. Runs entirely on local models (Ollama) with no cloud dependency.
• Zero phone-home. No analytics, no telemetry, no crash reporting, no auto-update checks.
• OS keychain for secrets. API keys are stored in the system keychain via keytar, never in plaintext config files.
• Enforced privacy tiers. Choose which provider tiers (local, open-source cloud, proprietary cloud) may be used. Every model call and external runtime is checked; a provider above the tier is refused with a reason, never silently swapped.
• Your data stays yours. All data lives in a local SQLite database and filesystem vault on your machine.

We welcome contributions. See CONTRIBUTING.md for development setup, PR guidelines, coding standards, and the role-pack contribution guide.

MIT © 2026 Rocky Elsalaymeh