Tell Panda what you need done. It finds a device and agent that can do the work and brings back the result.
Self-hosted · peer-to-peer · no vendor relay · ~40 MB RSS · macOS / Linux / Windows
English · 简体中文 · 日本語 · Español · Deutsch
Keep your existing agent or harness if it already handles the whole job. Add Panda when work has to move between machines and tools you manage, and you want the result, verification and blockers back in the original conversation. The agents still do the work; Panda handles dispatch and handoff without requiring a vendor-hosted scheduler or relay.
The v0.1.x product priority is to make that handoff reliable from the first request through recovery and delivery. An execution ending is not the same as its checks passing.
Full 81-second recording (MP4, 626 KB) · Console screenshot · Terminal still
Recorded 2026-11-06 on one macOS arm64 machine running v0.1.4 built from source. The clip runs panda version, panda doctor, panda queue, then panda ask -authorize with a request to run uptime and report the load average, and closes on the finished task in panda queue. Task 01a1b154-c86c-7600-a83d-f7d11ffbb26e ran through the opencode adapter and settled in 43 s. The uptime figures on screen come from a real shell call on that machine.
# macOS / Linux
curl -fsSL https://raw.githubusercontent.com/Xustalis/OpenPanda/main/scripts/install.sh | sh
# macOS (Homebrew)
brew install Xustalis/openpanda/openpandaWindows (PowerShell): irm https://raw.githubusercontent.com/Xustalis/OpenPanda/main/scripts/install.ps1 | iex
Then start a node:
panda init # auto-detects hardware; the one prompt is about the model
panda # the terminal TUI — or `panda web` for the consoleFrom source: git clone then make build (Go ≥ 1.26.11, no CGO). Already installed: panda update upgrades in place and keeps your data.
You already pay for Claude Code, Codex, OpenCode, or one of the other terminal agents. Each of them runs on one machine, in one terminal, on one conversation at a time. The second laptop idles while the first is busy, a long run dies when the lid closes, and nothing coordinates two agents editing the same project.
OpenPanda is the dispatch layer between you and those CLIs. You give one instruction; it classifies the intent, splits multi-stage work into a plan, routes each stage to the node and agent best suited to it, supervises the run, and re-dispatches with the failure reason attached when an executor dies. All of it on your own network. No hosted control plane, no account, no token markup; the only traffic that leaves your nodes is the model calls you configure.
It is not another agent. It drives the ones you already have.
Bundled adapters: Claude Code, OpenAI Codex, OpenCode, Grok Build, DeepSeek Harness, Antigravity, Hermes, Pi, ZCode, OpenClaw, plus a generic bridge for any other CLI that speaks stdin/stdout.
Setups people actually run:
- Claude Code on a laptop, Codex on a Linux build box, and a Raspberry Pi that stays on 24/7, all sharing one queue.
- One prompt fanned out to four agent harnesses in parallel, with a judged verdict instead of four answers to read yourself.
- A long refactor that keeps running after the laptop sleeps, because the work moved to a node that stays awake.
- A homelab or SBC fleet where every box has different hardware; the scheduler scores the nodes and picks the right one per task.
┌─────────────────────────────────────────────────────────────┐
│ You: One Command │
│ (Terminal TUI / Web Console / CLI Script) │
└──────────────────────────────┬──────────────────────────────┘
│
┌────────────▼────────────┐
│ 🐼 OpenPanda │
│ Route, Orchestrate, │
│ Verify & Secure │
└────────────┬────────────┘
│ Direct P2P links (WS + sealed UDP, no vendor relay)
┌─────────────────────────┼─────────────────────────┐
│ │ │
┌────▼──────────────┐ ┌──────▼────────────┐ ┌────────▼────────────┐
│ MacBook (Worker) │ │ Linux Build Box │ │ Raspberry Pi / SBC │
│ - Claude Code │ │ - Codex / Docker │ │ - 24/7 Daemons │
└───────────────────┘ └───────────────────┘ └─────────────────────┘
| Track | Description | Status |
|---|---|---|
| Task delivery | Dispatch to installed agents, track execution, recover where safe and return results with evidence | v0.1.x product priority |
| Multi-device collaboration | Cross-node task routing and scheduling over a P2P mesh | ✅ Shipped through v0.1.6: per-session AEAD, Bluetooth-style pairing, trust tiers, multi-hop relays, and same-project parallel execution via path-scoped lanes and isolated worktrees |
Capability-by-capability detail — what is verified, what is only built, and the known limits — lives in docs/status.md; work merged after the tag is listed in CHANGELOG.md under [Unreleased].
Shipped in v0.1.5. One through-line: no surface reports more than the machine actually did — not a bind, not a verdict, not an answer.
-
The node's reach is one switch —
network.exposure_mode(loopback·lan·public, with pre-0.1.5 configs read aslegacy) rewriteslisten_addr,panel_addr,udp_listenanddiscovery_*at load, sopanda doctor, the capability card and the sockets cannot disagree. A fresh install is loopback-only, andpublicrefuses to load without a stableshared_secretandpanel_token. -
Unchecked work says so — an agent run with no supervisor and no contract carries
verification: unverifiedinstead of a plaindone, a run that left no output and no changed file parks for review, and a delegated result whose checks stayed on the origin is labelled the same way. -
Small asks run locally —
启动 web 服务/run doctor/看看状态match a closed, whole-message table and execute this binary directly: 45 s cap, no shell, argv only from the table. Questions and compound requests stay on the task path, and a local failure falls through to it. -
A nine-page product site — overview, capabilities, docs, download, changelog, status, security, community and FAQ, with real console captures and an 81-second recording instead of a drawn mock.
-
Agent execution is configurable live —
routing.agent_models,routing.subagent_models,routing.agent_concurrencyand the delegation limits are validated, editable in Settings → Execution and applied to the running engine without a restart;docs/agent-execution.mdships in five languages. -
Long tool loops stay inside the context window — one result caps at 12,000 runes and the whole transcript at 12,000–64,000 runes, with a targeted recovery for overflow and containment for tool panics. Ask rounds are persisted (schema v67), summary delivery retries, and the MCP stdio transport is bounded and redacted.
-
Sandbox and pairing have real entry points —
sandbox.modeis written through Settings,/sandboxandpanda config sandbox get|setto the config, the live config and the process-wide policy together; inbound pairing requests surface in the console, TUI andpanda status, and LAN discovery reports why the peer list is empty. -
Memory edits are safe to make — daily logs, retrieval isolation, optimistic-lock versions and graph provenance were hardened in one pass.
Shipped in v0.1.6. One through-line: an execution is honest about what it actually finished — completion, recovery and stage contracts follow the work the machine did.
- Completion and recovery integrity — approval cannot close work already known to be unfinished, an external blocker requires changed input, and a partial or interrupted run is neither reported as success nor silently replayed on another agent. Recovery names its strategy, and native checkpoints survive bounded continuation.
- Stage contracts and critical-path scheduling — a plan stage carries
acceptance,success_definition,tools_policy,max_turnsand ablockedoutcome; independent local branches run in parallel and ready stages are ordered by a weighted critical-path heuristic. - Claude Code relays, read-only runs and evidence — model discovery reads CC Switch's provider list read-only while dispatch keeps the node's native relay endpoint; a task declares whether it may write, and repository questions require source evidence.
- A device pin stays a pin —
--nodes, the console selector andtask_submit.nodehard-pin a node;--preferredremains a soft hint that falls back withroute_fallbackrecorded, and a failed handshake names the secret, clock or identity mismatch. - One console surface, and Go 1.26.11 — side conversations, overview and notifications share one surface; the toolchain floor rises to clear GO-2026-6859. Configuration, stored data and the wire format are unchanged, and the schema stays at v67 — no migration, no new frame.
- Intent classification & task decomposition — the engine distinguishes chat, management queries, and executable tasks; multi-stage work is first split into a plan with artifact wiring between stages.
- Supervision loop — the entry model continuously judges task completion and re-dispatches with the failure reason attached, until done or the round budget (5 rounds by default) is spent.
- Multi-model registry & transparent failover —
panda model add|switch|testmanages several providers per node behind a health breaker; quota exhaustion or dead credentials (401/403) trigger automatic fallback-model injection, and the task continues instead of dying halfway. - Multi-harness runs —
panda task add --agents a,b --mode parallelfans one instruction out to several agents as a plan and collects the verdicts. - Transparent execution — every Bash command, file edit, and tool call, along with the responsible agent and underlying model, streams live to your terminal and console.
- Tiered approval — reversible operations run autonomously; irreversible actions (
git push, production database changes) suspend for explicit human confirmation. - Circuit breakers — loop detection and retry breakers stop runaway agents from burning tokens.
- Sibling message board (experimental) — tasks sharing a plan or a parent exchange short notes (a status line, a finding, a pointer to produced files) through a bounded slot board; each agent reads what its peers posted at its next round instead of blocking on their results, and a per-episode budget keeps the channel from becoming chatter.
- Dual-layer memory — user preferences (
USER.md) and project facts (MEMORY.md) are strictly separated. - Self-evolving skills — successful workflows are distilled into
SKILL.mdplaybooks that accumulate over time. - Skills Hub & autonomous discovery — a curated offline catalog (
panda skill hub), importing from a path, URL, or archive (panda skill import), and an assistant that finds and installs the skill a task needs mid-flight. - Traveling context — delegated tasks carry project memory and a workspace digest to the executing node.
- LAN auto-discovery + Bluetooth-style pairing — nodes find each other on the LAN with fingerprint-confirmed admission;
panda pairjoins a device via a short code confirmed on both ends, andpanda nodes verifypins each peer's Ed25519 key. - Capability cards — each node auto-declares its hardware and tool profile (CPU, RAM, OS, available agents).
- P2P mesh — nodes communicate over an authenticated WebSocket with negotiated per-session AEAD encryption, plus an encrypted UDP data plane with NAT traversal; data never leaves your private network.
- Trust zones — every peer carries an operator-set tier (
panda nodes trust <id> mesh|guarded|open) that clamps what a delegated task may expose to that peer and how work inbound from it is admitted; display content is mesh-only end to end, so a trust demotion cuts a screen transfer mid-flight. - Capability-based routing — the scheduler scores nodes on measured capacity and routes each task to the best match;
panda nodes drainparks a node for maintenance. - Worktree-traveling delegation — a file task delegated to another node carries its checkout there and brings the result back.
- Multi-hop mesh — hard pins (
--preferred, stagenode:) and the context/artifact data plane route over multiple relays on a partial mesh: a node two hops out is addressed through the gossiped link-state, and an executor that cannot reach the origin pulls its snapshot and inputs through the hop that handed it the task. - Actuator dispatch — tasks can drive physical actuators on the node that owns the hardware; seven reference drivers ship in
drivers/(servo, mic, camera, notify, serial MCU, screen capture, GUI input), with.ps1variants so stock Windows nodes need no git-bash. - Computer-use pair — a node with a desktop session advertises
hardware:screen_capture(screenshot the display) andhardware:gui_input(click, type, key, scroll — tier 2 because a click cannot be unsent), so the agent on that machine can see and drive its GUI; headless daemons never claim a screen they cannot see. Screen output only travels between mesh-trusted nodes. - Retrievable artifacts — what a task produces (a screenshot, a report file) is packed and pulled back to you:
panda task artifact <id>lists and extracts it, and the console previews images and text inline.
- Session trees —
panda session fork <id> --at Nbranches a conversation at any turn; in a repository the child's worktree branches off the parent's, so it inherits the code the parent produced.panda session treerenders the family,/forkdoes it inside the REPL/TUI. - Auto-compaction — overflowing history folds into a model-written running digest instead of being dropped; the stored thread stays whole.
panda mcp— exposes the node's own tools (tasks, memory, skills…) as an MCP stdio server, so any MCP-speaking agent can drive the node through the standard protocol.panda rpc(experimental) — NDJSON-over-stdio embedding surface (status, streamingask,session.*), so other tools can drive OpenPanda;scripts/panda_rpc.pyis a stdlib-only reference client.- Subscription OAuth (experimental) —
panda auth login anthropicsigns in a Claude Pro/Max subscription via PKCE with transparent token refresh.
- Terminal TUI (Bubble Tea): full-screen alternate-screen mode with keyboard navigation, first-run onboarding wizard, live progress, mid-turn steering;
PANDA_CLASSIC_REPL=1keeps the classic line REPL around. - Web console: zero-config kanban, real-time SSE streaming, skills management, session cancellation, automatic browser login;
panda web --lanshares it on the LAN behind an ephemeral token, with Web Push notifications. - Voice entry (experimental):
panda voiceruns the wake → transcribe → dispatch → speak loop through the bundledextensions/voicesidecar scripts (needs its own Python deps). - Scriptable CLI:
panda askdrops straight into automation scripts. - Self-updating:
panda update check|apply(orpanda upgrade) probes a staged binary and swaps it in place. - Featherweight: single static Go binary, ~40MB RSS, no external runtime dependencies.
Initialize your node (device name, resource class, and capability card are auto-detected; the one prompt asks whether to configure a model now):
panda initThen pick an entry point:
panda # interactive terminal TUI
panda web # or open the local web consoleSelect a familiar project and ask: “Run this project's tests, return the failures and raw output, and do not change source files.” Include the test command if you know it. Inspect the execution steps, output and verification in the original conversation.
To connect a second device: run panda pair <device-B-address> on device A and confirm the same short code with panda pair confirm on device B — or let LAN discovery surface it under panda nodes and admit it by fingerprint (panda nodes admit).
Try the same task on a paired build machine with the required toolchain and an installed agent. See the first-task walkthrough for prerequisites, routing and recovery.
| Command | Description |
|---|---|
panda |
Launch the interactive terminal TUI |
panda ask "<query>" |
One-shot: direct answer, tool call, or task dispatch (--agents a,b --mode parallel for a multi-agent run) |
panda web |
Start the web console and open the browser automatically (--lan to share) |
panda voice |
Talk to the node instead of typing (experimental) |
panda model |
Multi-model registry: status, add, switch, test |
panda nodes |
List online devices and capabilities; nodes trust <id> mesh|guarded|open pins a peer's tier |
panda pair |
Pair a new device over the LAN (short code confirmed on both ends) |
panda queue |
Inspect pending, running, and review tasks (--watch for live updates) |
panda approve <id> |
Approve a pending Tier-2 task |
panda plan run <file.yaml> |
Multi-stage, multi-device pipelines (plan example writes a starter) |
panda task board <id> |
Show the sibling-message boards a task reads (plan/parent scope + its children) |
panda task artifact <id> |
List or extract a task's output artifact (--list, --file <path>, --out <dir>) |
panda session |
List, fork, and resume conversation sessions (session tree shows the family) |
panda project list |
Manage workspace projects and context |
panda card |
Show, rescan, and edit this node's capability card |
panda skill |
Browse, import, and install workflow skills (Hub, URL, or file) |
panda auth login |
Sign in a model subscription (e.g. anthropic) via OAuth |
panda mcp · panda rpc |
Serve the node's own tools over MCP stdio · NDJSON embedding surface |
panda update |
Check for updates or self-update in place (upgrade applies directly) |
panda doctor |
Diagnose PATH, config, adapters, and database health |
panda version |
Print the current version |
┌─────────────────────────────────────────────────────────────┐
│ cmd/panda Terminal TUI · Web Console · CLI · Voice │
├─────────────────────────────────────────────────────────────┤
│ askengine Intent classification · management tools │
│ entry/plan Prompt build · multi-stage decomposition │
│ commander 3-Tier execution: Native · Agent · Manual │
│ defense Tiered gating · circuit breakers · anti-loop │
│ memory/skills Dual-layer memory + self-evolving SKILL.md │
├─────────────────────────────────────────────────────────────┤
│ sessions Conversation trees · forking · compaction │
│ auth/updater Subscription OAuth (PKCE) · self-update │
│ scheduler Capability scoring · latency-weighted routes │
│ trust Per-peer trust zones (mesh/guarded/open) │
│ bus/ledger WS + sealed-UDP transport · session AEAD · │
│ Ed25519 identity · capability cards │
│ artifact Chunked, resumable output bundles │
│ security Sandbox · net allowlists · secret redaction │
│ storage Pure Go SQLite (WAL mode) │
└─────────────────────────────────────────────────────────────┘
Released versions, newest first. Full entries, including every fix, live in CHANGELOG.md.
| Version | Theme |
|---|---|
| v0.1.6 (current) — "Constellation" | The patch that keeps a run honest about what it finished: approval cannot close known-unfinished work, recovery names its strategy instead of inferring cross-node replay safety, and a plan stage carries its acceptance contract through conversion. CC Switch and other Claude Code relays work without an official Anthropic key, read-only runs declare their boundary and repository answers carry source evidence, a hard device pin stays distinct from a soft preference, and the console folds side conversations, overview and notifications into one surface. The Go floor moves to 1.26.11 for GO-2026-6859. Configuration, stored data and the wire are unchanged, and the schema stays at v67 — no migration, no new frame. |
| v0.1.5 — "Constellation" | The patch where a surface stops claiming more than the machine did: one network.exposure_mode derives every listening socket, so a fresh install is loopback-only instead of binding every interface; an agent run with no supervisor and no contract reports verification: unverified instead of a plain done; and a bare imperative for this node's own console or doctor runs locally, without an entry-model call or a task row. A delegated run outlives the peer's link, concurrent waiters on one task all get the result, and the security docs and product site are rewritten where they had become false. Configuration, stored data and the wire format are unchanged — no migration, no new frame. |
| v0.1.4 — "Constellation" | The patch that makes the work verifiable and the console one place to work: every agent run starts with a deterministic workspace map — git state, layout, language mix, key files and the project's own build and verify commands — that also feeds classification, so scope, duration and turn budgets come from the real repository; completion is judged on the commands actually executed, the failed tool results and whether a declared verification entry ran, so a reply that claims tests passed without evidence is not completion; long and high-complexity tasks get matching turn and time budgets, an in-flight tool call is no longer mistaken for a stalled run, and a run stopped at its turn cap continues the same session under a higher cap. The entry model asks up to four bounded questions before dispatching a large ambiguous request and pauses on run / read-only / cancel, and an agent asks the same structured questions mid-run. The console folds the thread's side surfaces into one dock (unfinished work, referenced files, a fetched page, a read-only side chat), groups and discovers model accounts by connection, installs as a user-level service, and binds five task edges to operator hooks. Configuration gains only a default-off hooks section — no schema migration, no new wire frame. |
| v0.1.3 — "Constellation" | The patch that keeps the console live and the run alive: a console left open across a sleeping laptop, a reverse proxy or a busy node no longer freezes, and watching a run no longer costs more than the work it watches. A long agent run that prints nothing while it thinks is no longer killed as stalled, and the pre-first-output grace window now applies. The event feed reconnects on its own and a task timeline follows a cursor instead of re-downloading itself. Configuration and stored data are compatible — one additive index migration (v65) — and the wire adds no frame. |
| v0.1.2 — "Constellation" | The patch that gives a conversation a policy and a task its own evidence: five permission modes (auto, manual, accept-edits, plan, bypass) ride the thread and every task spec, so the executor applies the same autonomy the user granted — plan hands the agent the read-only tool face, manual holds every state-changing step for a foreground answer, bypass consents and is still audited. panda task add --accept turns a success definition into checks the orchestrator runs itself, comparing baseline against final so a suite that was already red is named as such; the executor refuses irreversible and peer-authored checks. The console gets the same care: floating workspace panels can no longer be dragged out of reach, the to-do board adds without a detour, and an agent this node lacks is not a pickable team member. Configuration and stored data are compatible — one automatic migration (v64) adds the contract tables — and the wire adds no frame. It also groups the model registry by connection — one endpoint and one key per account — and gives the auto-start service a usable PATH, so a daemon started at login finds the same agent CLIs a terminal session does. |
| v0.1.1 — "Constellation" | The patch that closed the seams of the release-grade line: the entry client speaks OpenAI Responses and Google Gemini natively, OpenCode Go / Console joins the built-in providers, a thread's roster and node pin reach the terminal beside the console (/team, /node, panda ask --team/--node, the to-do board), the dispatch budget follows the team you picked instead of a hard 3, cross-process writes are atomic behind a file lock, adapter probes stop repeating and the model breaker escalates, and a task can pin a work directory of its own. On the security side, a project can no longer turn one authenticated request into a viewer for the whole disk, sandbox.mode: strict refuses to run without its backend, and the console caps request bodies, event streams and agent probes. Configuration and stored data are unchanged — no schema migration, no renamed key — and the wire adds no new frame; the one incompatible edge is the UDP datagram plane against a 0.1.0 node, so upgrade a mesh together. |
| v0.1.0 — "Constellation" | The release-grade line's first stable cut, and the first with hardened installers (a downgrade guard on every path, a verified release signature): the Constellation feature set with the release audit's correctness and security fixes closed — multi-hop artifact pulls through relays, model-reported failures no longer settling as done, declined work falling back to a capable origin, hello identity pinning, a bounded project-pack admission gate, a UDP-plane crash fix, strict-mode secret read denial, and the standalone console's thread/skills APIs. Verified on a Mac → relay → cloud chain over a WAN link, including a 3 MiB project tree pulled end-to-end — and, since the first cut, console dictation over /api/voice/transcribe, a per-agent model pin under injection.agents, and device panels in the workspace. |
| v0.0.12 (preview) — "Constellation" | The fleet drawn as one sky, and agents flying in formation: same-project tasks run in parallel through declared path scopes and isolated worktrees under end-to-end delegation bounds; a running task takes a queued note or a live steer, and a round-budgeted park can be continued instead of only accepted or rejected. The web console consolidates into one place to work — queue, plans and projects merge into the Control page, a workspace page draws the whole fleet as a live topology map and dispatches turns straight into a picked thread, and a profile page answers who this node is and how busy it has been. Underneath: cross-process execution leases, context-overflow recovery, a per-model token policy over a catalogue moved to the current generation, PowerShell completion, pprof on the daemon — and a dispensation-attempt lifecycle fence that reroutes lapsed executor custody, orders outbox delivery across link flaps, and keeps stale verdicts from landing on rotated attempts |
| v0.0.11 — "Rendezvous" | Tightening the mesh itself: negotiated per-session AEAD encryption inside the signed hello, Bluetooth-style panda pair, signed discovery beacons and stable k:<pub> identities, hard node pins that hold their destination across multi-hop routes, outbox custody that re-delivers verdicts across link flaps, daemon-authority arbitration, a 240 s silence watchdog, negotiated binary data frames — and a partial-mesh data plane that relays context and artifacts along the delegation chain. It also ships the computer-use pair (hardware:screen_capture, hardware:gui_input; POSIX and Windows .ps1 drivers, advertised only under a real GUI session), retrievable task artifacts (panda task artifact, console preview), and a mesh-only trust rule for display content that follows the bytes through sends, pulls and stage-to-stage input handoffs |
| v0.0.10 — "Apoapsis" | Reaching outward to the LAN and the edge: discovery with fingerprint-confirmed admission and TOFU key pinning, worktree-traveling delegated file tasks, the clarification loop, actuator dispatch with five reference drivers (serial MCU included), the Pi adapter and a Python-free generic executor — plus session trees with forking, auto-compaction, the panda rpc embedding surface, subscription OAuth, signed event/audit chains, OS-level sandboxing, and a steady-state perf round. Relicensed to AGPL-3.0-or-later with dual commercial licensing |
| v0.0.9 (stable) — "Periapsis" | Hybrid transport/DTN architecture completed: latency-weighted mesh routing, on-wire DTN bundles, token budgets, shadow copies, actuator path, UDP datagram plane with mesh-coordinated NAT hole punching, encrypted payloads, contact plans, Ed25519 node identity, lite build — plus remembered approvals, execution attribution, a web sidebar node chip and everyday CLI polish |
| v0.0.8 (stable baseline) | Single-machine multi-agent orchestration, fully usable: intent classification, dispatch, supervision loop, failover, tiered approval, prompt language policy |
Where the project goes next. The v0.0.x kernel track is complete and stays here for context.
| Version | Theme |
|---|---|
| v0.0.x — the kernel | Polish the kernel until every shipped feature is proven. The Experimental tracks graduate to stable through real-device fleet validation — LAN discovery & fingerprint admission, pairing + per-session AEAD, trust zones, the inter-task message board, session trees/RPC/OAuth, worktree-traveling delegation, the clarification loop, actuator drivers, computer-use, and the voice entry — plus first hardware ignition of the reference drivers, and steady stability, performance and edge-case tuning throughout |
| v0.1.x — task delivery | A task stays one job even when its execution moves. Prioritize capability-aware dispatch, safe recovery, and results returned with verification and open items. Desktop and mesh improvements support that path. See the product direction. |
| v0.2.x — self-evolution | OpenPanda iterates on itself. Self-modification lands as agent-produced patch sets through a build → gate → human-merge pipeline coexisting with the signed release channel; node-signed self-builds become a third provenance class under the trust zones; self_evolution.mode (off → propose → auto) with the last signed release always kept as fallback — the complete agent self-evolution paradigm |
Today, OpenPanda focuses on the devices and agents developers already manage. Deep-space satellites illustrate the same problem at its limit: different machines have different capabilities, and their links may come and go. That is a long-term direction, not a supported deployment or evidence of flight testing.
The doc set lives under docs/: project status (what is verified vs. only built), the install guide, the FAQ, the bus protocol reference, and the agent execution guide (model selection, concurrency and hot reload). Install, FAQ, status and protocol each have an English edition; the execution guide has all five. The repository also tracks the policy and legal texts, the licensing note, the AI-agent working notes (CLAUDE.md / AGENTS.md) and the current growth plan (GROWTH-PLAN.md); historical design drafts and test runbooks are maintained outside it.
- Read CONTRIBUTING.md for code standards and workflow.
- Check SECURITY.en.md for security guidelines (the canonical text is the Chinese SECURITY.md).
- Abide by the CODE_OF_CONDUCT.md.
- Run
make gatelocally before submitting a PR. - Non-trivial contributions require CLA assent — see CLA.md; typo/docs fixes and
adapters/changes are exempt.
OpenPanda is dual-licensed:
- Community — GNU Affero General Public License v3.0 or later (AGPL-3.0-or-later)
- Commercial — proprietary terms for closed-source embedding or hosted use; see COMMERCIAL.md
LICENSING.md holds the trademark notice, the terms that ride alongside the AGPL, and the licensing of earlier releases. Releases published before the license change remain available under the MIT License.
Use of OpenPanda is subject to the Terms of Use & Disclaimer (中文 · 日本語 · Español · Deutsch).
