parallax-agent-runtime
MCP server for AI agent orchestration - spawn, manage, and coordinate multiple AI agents
Installation
npx parallax-agent-runtimeAsk AI about parallax-agent-runtime
Powered by Claude Β· Grounded in docs
I know everything about parallax-agent-runtime. Ask me about installation, configuration, usage, or troubleshooting.
0/500
Reviews
Documentation
Parallax
Pattern-driven agent orchestration with runtimes, workspaces, and managed threads
Website Β· Docs Β· Pattern Builder
What Parallax Is
Parallax is a control plane for orchestrating agents with explicit patterns, org charts, and runtime-backed execution.
At its core, Parallax gives you:
- Prism patterns and primitives for explicit orchestration logic
- A control plane that loads patterns, manages executions, and streams events
- Multiple runtimes for local PTY sessions, Docker containers, and Kubernetes pods
- Managed threads for long-lived supervised work, especially coding tasks in mutable workspaces
- Workspace and memory services for repo provisioning, shared decisions, and episodic experience reuse
The architectural model is:
agent= execution substratethread= orchestration substrate
That keeps Parallax explicit and deterministic while still supporting long-running CLI-agent work with tools like Claude Code, Codex CLI, Gemini CLI, and Aider.
Current Architecture
Parallax is organized into four main layers:
- Client layer CLI, web dashboard, docs site, and external API consumers.
- Control plane Pattern engine, Prism runtime, execution management, thread persistence, memory, scheduling, and workspace preparation.
- Runtime layer
runtime-local,runtime-docker, andruntime-k8simplement agent and thread execution. - Agent layer SDK agents plus interactive coding CLIs and other runtime-backed workers.
Key architectural capabilities today:
- pattern-driven orchestration with Prism and reusable primitives
- explicit org-chart and workflow execution
- managed thread APIs for spawn, supervision, events, input, and stop
- workspace-aware coding execution with context file injection
- shared decisions and episodic experiences for future thread preparation
- runtime abstraction across local, Docker, and Kubernetes
For the deeper architecture docs, start here:
Core Concepts
- Patterns define orchestration logic in Prism or compiled YAML.
- Primitives are the reusable building blocks for execution, aggregation, control, confidence, and thread supervision.
- Runtimes are the execution backends that actually host agents or CLI workers.
- Managed threads are the long-lived units the control plane supervises over time.
- Workspaces provide repo-aware execution contexts for coding tasks.
- Memory captures compressed decisions and prior outcomes for future work.
Quick Start
Prerequisites
- Node.js
>= 18 pnpm >= 10.11.0- Docker for local infrastructure
Install
pnpm install
pnpm build
Start the platform
Basic local startup:
pnpm start
This is the simplest way to bring up Parallax for development.
If you want the fuller local stack, including database-backed control-plane features:
pnpm run infra:all
pnpm run dev:control-plane
Useful next commands:
pnpm run dev:web
pnpm run demo:patterns
pnpm run test
pnpm run type-check
For more startup modes, see:
Managed Threads
Managed threads are now a first-class part of Parallax.
Use them when you need:
- long-horizon coding tasks
- supervised CLI workers in real repositories
- normalized events like
thread_ready,thread_blocked, andthread_turn_complete - memory injection before spawn
- durable thread state and event history
The main REST surface lives under:
/api/managed-threads
See:
Repository Structure
parallax/
βββ apps/
β βββ builder/ # Pattern Builder app
β βββ docs/ # Docusaurus docs site
β βββ marketing/ # Marketing site
β βββ web-dashboard/ # Web dashboard
β βββ demo-*/ # Demo applications
βββ packages/
β βββ control-plane/ # Main orchestration service
β βββ primitives/ # Prism primitives
β βββ pattern-sdk/ # YAML/SDK tooling for Prism generation
β βββ org-chart-compiler/ # Org-chart compilation to executable workflows
β βββ runtime-interface/ # Shared runtime and thread contracts
β βββ runtime-local/ # Local PTY-based runtime
β βββ runtime-docker/ # Docker runtime
β βββ runtime-k8s/ # Kubernetes runtime
β βββ runtime-mcp/ # MCP surface for runtime and thread operations
β βββ coding-agent-adapters/ # Claude/Codex/Gemini/Aider adapter layer
β βββ pty-manager/ # PTY session manager used by local execution
β βββ git-workspace-service/ # Workspace provisioning and repo operations
β βββ sdk-typescript/ # TypeScript agent SDK
β βββ sdk-python/ # Python agent SDK
β βββ sdk-go/ # Go agent SDK
β βββ sdk-rust/ # Rust agent SDK
β βββ ... # Auth, telemetry, monitoring, CLI, and support packages
βββ patterns/ # Example patterns and compiled workflow artifacts
βββ scripts/ # Development, smoke, and maintenance scripts
βββ k8s/ # Kubernetes manifests and Helm charts
βββ docs/ # Internal architecture and implementation docs
What To Read Next
Links
- Website: https://parallaxai.dev
- Docs: https://docs.parallaxai.dev
- Pattern Builder: https://builder.parallaxai.dev
- GitHub: https://github.com/HaruHunab1320/parallax
- Discord: https://discord.gg/jdjqvMa2
- X: https://x.com/Parallax__AI
Licensing
Parallax is open source at the core under Apache 2.0, with enterprise features
available under a commercial license. See LICENSE and LICENSE-ENTERPRISE.
