PaddleBoard

PaddleBoard is a fork of Zed tuned for AI-native development. It keeps Zed’s speed, GPU-accelerated rendering, LSP, debugger, terminal, and git workflow, then layers on the pieces a modern coding agent actually needs — on your terms:

• Bring-your-own-key models — OpenAI, Anthropic, Google, Vertex AI, Bedrock, and more. No hosted plan, no upsells.
• An agent workbench — an agent panel with delegation, plus first-class support for the ADK, LangGraph, CrewAI, and AutoGen frameworks.
• The AI Dock — install and manage agents, skills, and MCP servers from one place.
• Private by default — telemetry is hard-disabled at the source; no account required.

Status: alpha. Build from source — there are no released binaries yet, and builds are not yet notarized by Apple. See Getting Started.

These docs are task-oriented “how-to” guides. For a quick in-app tour, open the command palette and run workspace: Open Paddle Board Tour.

Getting Started

PaddleBoard is alpha and currently builds from source — there are no released binaries yet.

Prerequisites

• Rust (via rustup).
• macOS: Xcode + Xcode command-line tools, and cmake.
• Linux: run script/linux to install system dependencies.
• Windows: Visual Studio with the C++ toolchain, the Windows SDK, and cmake.

Build and run

git clone https://github.com/paddleboarddev/paddleboard.git
cd paddleboard
cargo run -p paddleboard

The first build takes a while (it compiles the whole workspace). Subsequent runs are fast.

First steps

1. Add a model. PaddleBoard ships with no model configured — open the agent panel and add your own API key for a provider. See Configuring LLM Providers.
2. Open a project. Common languages work immediately; others are one click away in Language Support.
3. (Optional) Save your git credentials so pushes don’t prompt — see Git Login.

A note on macOS Gatekeeper

PaddleBoard is not yet code-signed or notarized with an Apple Developer ID. Building from source yourself is unaffected. Once distributed binaries exist, macOS will warn that “Apple cannot check it for malicious software” until notarization is in place — you’d allow it via System Settings → Privacy & Security.

Configuring LLM Providers

PaddleBoard is bring-your-own-key: you connect your own model accounts. There is no hosted PaddleBoard plan, and nothing is gated behind a PaddleBoard sign-in.

Add a provider

1. Open the agent panel.
2. Open agent settings → Configure Providers (or the command palette → provider config).
3. Pick a provider, paste your API key, and save. Keys are stored in your OS keychain (never in settings or plaintext).

Most providers also read a standard environment variable (e.g. ANTHROPIC_API_KEY, OPENAI_API_KEY) as a fallback.

Supported providers

Includes Anthropic, OpenAI (and ChatGPT subscription auth), Google AI (Gemini), Google Vertex AI, Amazon Bedrock, DeepSeek, Mistral, OpenRouter, Vercel AI Gateway, and local runners (Ollama, LM Studio).

Google Vertex AI (Gemini Enterprise)

Vertex is a PaddleBoard addition for teams whose Gemini access runs through Google Cloud. It supports three auth modes, in precedence order:

1. Service-account key — set credentials_path to a service-account JSON file.
2. Express API key — paste an AI Studio / Express key.
3. gcloud (recommended, no stored secret) — run gcloud auth login once; PaddleBoard borrows short-lived Application Default Credentials. Just set project_id (and optionally location, default global) and it works.

Configure it from the provider settings (project id, location, optional credentials path). Newer models (e.g. Gemini 3) live on the global location, which is the default.

Privacy

Telemetry is hard-disabled in PaddleBoard — your prompts and usage never leave your machine except for the calls you make directly to your chosen provider.

The AI Dock

The AI Dock is one place to browse, install, and create the AI building blocks PaddleBoard supports: agents, skills, and MCP servers.

Open it from the command palette → ai dock: Open.

Tabs

• Agents — register a custom agent server by registry ID (Add Agent), or install a catalog agent. CLI-based agents (e.g. Google ADK) show a Set Up button that opens a terminal with the install command rather than running it inside the app.
• Skills — install bundled slash-command skills (/build, /update-tour, /clippy, /test, /check-drift) with Add to project / Add to user, or Create Skill to write a new .claude/commands/ markdown command.
• MCP — add and manage Model Context Protocol servers, with live status and streaming logs. See Sandboxed Execution & MCP.

The catalog is data-driven from assets/ai_dock/catalog.json in the repo — additions are pull requests, not network fetches.

Agent Frameworks

PaddleBoard has first-class support for four Python agent frameworks: Google ADK, LangGraph, CrewAI, and AutoGen. When you open a project that declares one of them (in pyproject.toml / requirements.txt), PaddleBoard detects it and offers to run it.

Running a framework

Each framework registers command-palette actions, e.g. adk: Run Agent, crewai: Run Agent.

• Dev-server frameworks (ADK, LangGraph, AutoGen Studio) launch a local server and forward its port into the embedded browser. For example autogen: Run Agent runs autogenstudio ui --port 8081 and streams startup logs to a tab.
• One-shot frameworks (CrewAI) run to completion and stream output to a tab — no port forwarding (crewai: Run Agent → crewai run).

Scaffolding

Frameworks with a project generator expose a Scaffold action (e.g. adk: Scaffold Agent, crewai: Scaffold Agent) that opens a small modal and runs the create command in a terminal.

Installing the CLIs

The frameworks themselves are external tools — install them in your environment (e.g. pip install crewai, pip install autogenstudio). PaddleBoard drives them; it doesn’t bundle them.

Scion: Isolated Parallel Agents

Scion runs “deep agents” as isolated, concurrent processes — each in its own container and git worktree. PaddleBoard integrates with a local Scion daemon so you can launch and watch those agents from the editor, and even delegate subtasks to them from your own agent.

Enable it (opt-in)

Scion is off by default. Turn it on in your settings:

{
  "paddleboard_scion": { "enabled": true }
}

Then install the Scion CLI and initialize it:

go install github.com/GoogleCloudPlatform/scion/cmd/scion@latest
scion init --machine   # one-time, sets up the container runtime
scion init             # in your project

Scion needs a container runtime (Docker / Podman / Apple Container).

Use it

• scion: Start Agent (command palette) opens a modal — set a task, name, and template.
• The Orchestration Panel shows a Scion Agents section with each agent’s phase (provisioning → running → stopped) and activity (working, thinking, waiting…). Right-click a row for View Logs (live-streaming), Sync Changes (pull its worktree changes into your project), or Stop Agent.
• Delegation: when enabled, your agent gains a spawn_scion_agent tool — it can hand a subtask to a container + worktree-isolated Scion agent (instead of an in-process sub-agent that shares your workspace), wait for it, and return the result.

Telemetry (optional)

Scion can export agent-lifecycle traces over OpenTelemetry. See the Settings Reference for paddleboard_otel.

Language Support

PaddleBoard keeps the default install lean with two tiers.

Ready to use

Common languages — Rust, TypeScript/JavaScript, Python, Go, JSON, YAML, HTML/CSS, and more — are enabled by default. Open a matching file and the language server attaches automatically, downloading on first use.

Install support (opt-in)

Languages that need an external toolchain are opt-in. Run Manage Languages from the command palette to enable them; each row shows its prerequisite up front so it never fails silently when the runtime is missing.

Six ship a built-in server:

Ruby and Dart get their servers from extensions, so their row opens the Extensions page.

Why opt-in? It keeps the default install small and means you choose to pull in a heavier toolchain knowingly, rather than hitting a confusing “server reset the connection” crash when the runtime isn’t present.

Git Login

Save your git host credentials once so HTTPS git operations stop prompting on every clone/fetch/push.

Save a login

Run git login: Manage from the command palette:

1. Pick a provider — GitHub, GitLab, BitBucket, or a custom host.
2. Enter your username and paste a Personal Access Token (the modal links straight to the provider’s token page and lists the scopes to grant).
3. Save. The token is written to your OS keychain — never to settings or plaintext.

After that, git HTTPS clone / fetch / push authenticate silently. The password prompt only appears when there’s no saved login. Remove clears a saved login.

Environment-variable fallback

If you’d rather not store a token, set one of these and PaddleBoard answers git auth from it:

export GITHUB_TOKEN=...      # or GITLAB_TOKEN / BITBUCKET_TOKEN

Notes

• PaddleBoard sends the conventional token username per provider unless you set your own: x-access-token (GitHub), oauth2 (GitLab), x-token-auth (BitBucket).
• PAT-only today — no OAuth sign-in yet.
• HTTPS only. SSH key passphrases and host-key confirmations are untouched and still prompt as usual.

Sandboxed Execution & MCP

PaddleBoard can run agent-invoked code and MCP servers inside an isolated container instead of directly on your host.

Secure agent sandbox

Tool calls that execute code run inside an ephemeral ubuntu:latest container via Podman + the runsc (gVisor) kernel runtime. Your project is bind-mounted; the rest of the host filesystem is not exposed. Permissions still flow through the normal approve / deny / always-allow UI.

A status-bar shield shows live prereq status. If Podman/gVisor aren’t available, behavior is governed by paddleboard_sandbox.on_missing_runtime:

• block (default) — opens the install modal.
• fall_back_to_host — run on the host instead.
• warn_once — warn, then run on the host.

Sandboxed MCP servers

A sandboxed_stdio context-server transport runs MCP servers inside Podman + gVisor too, proxying stdin/stdout transparently so the JSON-RPC framing is unchanged. It’s opt-in per server; the plain stdio transport still works for servers that don’t need isolation.

Manage servers from the MCP tab of the AI Dock, or the dedicated MCP Servers settings page (command palette → zed: Mcp Servers), which lists configured servers and surfaces status and logs without hand-editing JSON.

Settings Reference

PaddleBoard-specific settings (on top of all of Zed’s). Add them to your settings.json.

Scion

{
  "paddleboard_scion": { "enabled": false }
}

Enables the Scion integration (default false). Installing the scion CLI alone does not activate it — this toggle does.

OpenTelemetry (Scion tracing)

{
  "paddleboard_otel": {
    "enabled": false,
    "endpoint": "http://localhost:4317",
    "protocol": "grpc"
  }
}

Exports Scion agent-lifecycle traces over OTLP to a collector (Jaeger, Tempo, etc.). Can also be enabled with PADDLEBOARD_OTEL_ENABLED=1.

Sandbox

{
  "paddleboard_sandbox": { "on_missing_runtime": "block" }
}

Controls what happens when the Podman/gVisor sandbox prerequisites are missing: block (default), fall_back_to_host, or warn_once.

Vertex AI

Configured under the Vertex provider settings — project_id, optional location (default global), and optionally credentials_path (service-account JSON) or an Express key. See Configuring LLM Providers.

Telemetry

There is nothing to configure: telemetry is hard-disabled in PaddleBoard. Events are dropped at the source and never reach the network.