Common Agent Runtime Parslee AI

Use this command to install Common Agent Runtime:

winget install --id=Parslee.Car -e

Common Agent Runtime (CAR) is a deterministic execution layer designed to validate, verify, and execute actions proposed by AI agents. This software provides pre-built Windows x64 binaries, including a command-line interface (car), a WebSocket server (car-server), and an evaluation bridge for StateBench (car-memgine-eval).

Key Features:

Verification: Proves plan properties such as safety, equivalence, and optimality before execution.
Policies: Enforces Rust-based constraints on actions to ensure secure and predictable behavior.
State Management: Maintains a typed key-value store with snapshotting and rollback capabilities.
Graph Memory: Enables spreading activation and context assembly for grounded LLM interactions.
Skills: Learns and evolves reusable procedures from execution traces.
Tools: Callback-based tool implementation, with the runtime managing dependencies.
Workflows: Supports multi-stage pipelines with conditional logic and compensation on failure.
Conformance Tests: Ensures consistent execution semantics across implementations.
Unified Inference: Supports local and remote inference through a provider-agnostic protocol.

Audience & Benefit: Ideal for developers building AI-driven applications, CAR ensures safer, more predictable interactions by validating plans before execution. It enables efficient resource management, reduces hallucinations, and improves reliability through rigorous testing and policy enforcement. The runtime can be installed via winget, making it accessible for integration into various development workflows.

This software is designed to empower developers with robust tools for building reliable AI systems, ensuring consistent behavior across different implementations while maintaining security and efficiency.

Common Agent Runtime (CAR)

A deterministic execution layer for AI agents, written in Rust. Models propose. The runtime validates, verifies, and executes.

Agents that pass raw LLM output straight into tool calls fail unpredictably — unsafe actions, hallucinated tool names, state drift. CAR treats plans as first-class data: verify before executing, enforce policies in Rust before any side effect, track memory as a graph, and learn reusable skills from execution traces.

This repo is the public binary distribution — install, docs, examples, issue tracker. The source is private (see License).

What it does

A single signed binary with:

Verify before execute — prove plan properties (verify, simulate, equivalent, optimize) before anything side-effecting runs.
Policies in Rust — enforced on every action before a tool fires (deny_tool, deny_tool_param, require_state), plus risk tiers with human-in-the-loop approval and per-agent permissions.
Graph memory + skills — spreading-activation memory, 4-layer context assembly for grounding LLM calls, and learned procedures that distill from traces and evolve when they degrade.
Unified inference — local backends (Candle + MLX: Qwen3, Gemma, vision, embeddings, image/video) and remote providers (OpenAI/Anthropic/Google) behind one protocol, with an adaptive local-vs-remote router.
Agents at scale — multi-agent coordination (swarm/pipeline/supervisor/ map-reduce/vote), declarative workflows, a scheduler, and browser automation.
Voice + desktop (macOS) — STT/TTS in-process, two-track voice dispatch, and Apple framework providers (Speech, Vision, NaturalLanguage, Translation).
Everywhere — Python + Node bindings, Swift/Kotlin via UniFFI, and a car-server JSON-RPC WebSocket surface any language can drive.

→ The data shapes and semantics these build on: SPEC.md.

What using it looks like

import json
import car_runtime

rt = car_runtime.CarRuntime()

# Tools are callbacks — you own the implementation.
rt.register_tool("shell")

# Policies are enforced in Rust before any tool fires.
rt.register_policy("no_rm", "deny_tool_param",
                   target="shell", key="command", pattern="rm -rf")

# A proposal is a DAG of actions with dependencies.
proposal = json.dumps({"actions": [
    {"id": "a1", "type": "tool_call", "tool": "shell",
     "parameters": {"command": "ls"}, "dependencies": []},
]})

# Verify first — catches bad plans before any side effect.
check = json.loads(rt.verify_proposal(proposal))
if not check["valid"]:
    raise RuntimeError(check["issues"])

# Execute with your tool dispatch.
def tool_fn(tool, params_json):
    return json.dumps({"stdout": "..."})

result = json.loads(rt.execute_proposal(proposal, tool_fn))

You want…	Do this
CAR on a Mac, no terminal	Download `CAR-darwin-arm64.pkg` from the latest release and double-click. Installs the CAR Host menu-bar app and the `car` CLI. Signed, notarized, auto-updating.
To build on CAR in Python / Node	`pip install car-runtime` · `npm install car-runtime`
The CLI on Linux / Windows, or scripted installs	Homebrew · Scoop · install script · tarball — see DISTRIBUTION.md

Doc	What's in it
SPEC.md	Proposal/action shape, tool + agent contracts, policy semantics, verification guarantees, conformance.
GUIDE.md	Copy-paste-into-an-LLM prompts to build a single agent and a multi-agent learning system.
DISTRIBUTION.md	Platforms, every package (PyPI/npm/Homebrew/Scoop/winget/pkg/tarball), release-asset contract.
SECURITY.md	Signing/notarization, verifying a download, the sealed-binary trust boundary, reporting a vulnerability.
BENCHMARKS.md	How the numbers are produced + how to reproduce; live results in LEADERBOARD.md.
CHANGELOG.md	Per-release changes.

Common Agent Runtime Parslee AI

README

Common Agent Runtime (CAR)

What it does

What using it looks like

Install

Quickstart

Documentation

Versioning

Issues

License