Taming Agent Fragmentation: Why Running Multi-Model AI Locally Demands a Unified Daemon

Every developer adopting AI assistance hits the exact same wall within a month: provider lock-in combined with cognitive thrashing. One model excels at high-level systems architecture, another writes cleaner unit tests, and a third runs your refactoring scripts. In practice, this means juggling three terminal sessions, re-authenticating across fragmented CLI tools, and losing context every time you switch windows. Shipping raw code to proprietary cloud hubs just to coordinate these tools introduces unnecessary latency and security compromises.

Paseo fixes this fragmentation problem from the metal up. Instead of trying to be another hosted SaaS wrapper, it deploys as a self-hosted, multi-provider orchestrator that binds Claude Code, Codex, Copilot, OpenCode, and Pi into a single local control plane.

+-------------------------------------------------------------------------+
|                              PASEO CLIENTS                              |
|   Desktop (Electron)  |  Mobile (Expo)  |  Web UI  |  CLI  |  VS Code   |
+-------------------------------------------------------------------------+
                                    │ (WebSocket / Relay)
                                    ▼
+-------------------------------------------------------------------------+
|                           PASEO DAEMON (Server)                         |
|   - Agent Process Orchestration                 - MCP Server Host       |
|   - Local Worktree Management                   - E2E Encrypted Relay   |
+-------------------------------------------------------------------------+
          │                     │                     │
          ▼                     ▼                     ▼
   [ Claude Code ]          [ Codex ]          [ GitHub Copilot ]
   [   OpenCode  ]          [   Pi    ]

The Engine: Daemon-First Process Isolation

The core design decision behind Paseo is the decoupling of the client interface from agent execution. Everything hinges on a local daemon (packages/server) that manages process lifecycles, exposes a WebSocket API, and runs a Model Context Protocol (MCP) server directly on your hardware.

Because the daemon owns the execution context, your clients become interchangeable viewports. You can dispatch a complex refactoring job from your terminal, monitor the raw token stream from the desktop app, and approve changes from your phone.

Feature	Paseo Architecture	Standard Multi-Tool Setup
Execution Surface	Local Daemon (`packages/server`)	Fragmented CLI instances
Telemetry & Tracking	Zero telemetry, zero forced log-ins	Dependent on individual vendors
Cross-Device Control	Desktop, Web, iOS, Android, CLI	Terminal-bound per machine
Agent Interop	Native skills (`/paseo-handoff`, loops)	Manual copy-pasting of context
Remote Access	E2E encrypted relay or direct TCP/Tailscale	SSH tunneling or custom reverse proxies

The local runtime preserves total environment sovereignty. The agents read your local configuration files, use your local toolchains, and write to your local git worktrees. No proprietary intermediary gets between your code and the underlying model endpoints.

Deployment Topologies: Desktop, Headless, and Containers

Before launching Paseo, ensure you have installed and authenticated your target CLI agents (Claude Code, Codex, GitHub Copilot, OpenCode, or Pi).

Option 1: Native Desktop Execution

The Electron desktop application (packages/desktop) serves as the fastest ramp for local dev boxes. It automatically manages the daemon lifecycle in the background.

Download the binary directly from paseo.sh/download or GitHub Releases.
Launch the application to boot the background server instantly.
Open Settings > Select Host > Pair Device to link external clients via end-to-end encryption.

Option 2: Headless Environments and Remote Workstations

For headless devboxes, cloud compute instances, or remote dev servers, install the CLI globally:

bash
npm install -g @getpaseo/cli
paseo

When you start the CLI, Paseo initializes the runtime and asks if you want to enable an end-to-end encrypted relay for remote pairing. If your setup uses Tailscale, VPNs, or direct TCP networks, decline the relay prompt to keep traffic strictly local.

Option 3: Containerized Daemon

To run the daemon alongside the self-hosted Web UI inside an isolated container, mount your local workspace and persistent configuration volumes:

bash
docker run -d --name paseo \
  -p 6767:6767 \
  -e PASEO_PASSWORD=change-me \
  -v "$PWD/paseo-home:/home/paseo" \
  -v "$PWD:/workspace" \
  ghcr.io/getpaseo/paseo:latest

Open http://localhost:6767 to reach the UI. Extend this base image with your required agent binaries and supply the relevant credentials either via environment variables or directly inside the mounted /home/paseo volume.

Command-Line Execution Workflows

The paseo CLI provides precise control over local or remote agent runtimes without opening a graphical window.

Spin up a task using a specific provider and model:

bash
paseo run --provider claude/opus-4.6 "implement user authentication"

Isolate an agent inside an independent git worktree to avoid branch collisions:

bash
paseo run --provider codex/gpt-5.4 --worktree feature-x "implement feature X"

Audit your active execution threads:

bash
paseo ls

Attach your terminal directly to a running process to stream its output in real time:

bash
paseo attach abc123

Inject new instructions into an active agent context:

bash
paseo send abc123 "also add tests"

Route a command directly to a remote host over the network:

bash
paseo --host workstation.local:6767 run "run the full test suite"

Agent Orchestration: Collaborative Workflows

Running multiple agents simultaneously is helpful, but making them collaborate changes how you write software. Paseo adds custom orchestration skills directly to the agent runtime.

Install the orchestration capabilities into your environment:

bash
npx skills add getpaseo/paseo

Once installed, invoke these orchestration patterns inside agent sessions:

/paseo-handoff: Chains discrete agent capabilities. Have one model draft the implementation plan, then hand off execution directly to another model to write the code.
/paseo-loop: Forces an agent to run iteratively against explicit acceptance criteria and automated verifiers (Ralph loops), refining the patch until it passes.
/paseo-advisor: Spawns a secondary agent to provide architectural critique or review without passing away primary context control.
/paseo-committee: Convenes a two-agent panel dedicated strictly to root-cause analysis and complex debugging.

Monorepo Architecture

Paseo is maintained as a cohesive monorepo composed of domain-isolated packages:

paseo/
├── packages/
│   ├── server/       # Core daemon, WebSocket API, MCP server, process control
│   ├── app/          # Shared Expo client powering iOS, Android, and Web
│   ├── cli/          # Terminal interface for daemon and task interactions
│   ├── desktop/      # Electron-based desktop shell
│   ├── relay/        # Transport protocols and payload encryption
│   └── website/      # Documentation and portal (paseo.sh)

The wider ecosystem contains several dedicated repositories:

getpaseo/paseo-relay: The official distributed relay infrastructure written in Elixir.
paseo-skins: Community themes and the desktop custom skin loader.
paseo-vscode: The native VS Code workspace extension.

Developer Sovereignty Over Fragmented SaaS

Paseo shifts multi-agent workflows away from disjointed terminals and closed SaaS platforms. By managing multiple agents through a single local daemon, you maintain full control over your environment, eliminate telemetry leaks, and let your tools collaborate directly in your local codebase.

Project Resources

Repository: https://github.com/getpaseo/paseo
Documentation: https://paseo.sh