Praxis

Self-hosted · Built in Rust

From a decision
to a verified result.

Give your AI agents a runtime. Praxis connects your models to explicit workflows, practical tools and checks that determine when the work is done.

Run Praxis Explore verified execution

Web dashboard, terminal chat and Discord.
One runtime on your own machine.

Workflow / verified codingIllustrative example
Requested action

Apply the change.
Prove it passes.

  1. 01
    Read & decideInspect source and its current hash
    R
  2. 02
    Apply a contractSnapshot, modify, check or restore
    M
  3. 03
    Verify the resultBuild and test the current workspace
    B · T
Execution receiptoutcome: committed
verified: true
Runtime
verified

Completion requires current receipts. What is verified depends on the checks in your contract.

Choose your models

01 / The runtime

Make the workflow
part of the system.

The model chooses an action. Your workflow defines the capabilities it can use and the evidence needed to move forward.

01

Explicit states

Define roles, prompts and tool access in .sm files. The Decision router can select declared states with a probability threshold.

02

Actions with contracts

Opt into capabilities with preconditions, postconditions and rollback. Failed source checks can restore the original file.

03

Evidence for completion

Require current, task-owned execution receipts before a state transition or completion. A model's claim alone cannot satisfy a receipt guard.

02 / Workflows

Small instructions.
Defined effects.

Praxis Decision IR maps a compact instruction to a trusted capability. The same contract, verification and receipt rules apply.

Use your normal chat model, including Ollama. The verified Rust workflow is an opt-in example you can adapt to your project.

Set up the IR workflow
verified-implementation.smWorkflow excerpt
# Operator-selected project, checked first
[workspace]
required_files = ["Cargo.toml", "Cargo.lock"]
required_directories = ["src"]

[decision_ir]
R = inspect_file
M = verified_rust/modify_source
B = verified_rust/build_workspace
T = verified_rust/run_workspace_tests
C = agent_complete
execute_decision{"ir":"1 R {\"path\":\"src/main.rs\"}"}

03 / Packages

A small kernel.
Installable packages.

Tools, services, the dashboard, the TUI, memory, scheduling and skills arrive as packages. The kernel loads them, authenticates callers and keeps every authority.

01

Everything is a declaration

Tools, routes, UI, assets and migrations live in plugin.json. Install, upgrade or remove a package without patching the runtime; missing, disabled or unready code fails closed.

02

Trust is granted

A package declares the role it wants and the operator grants it. Install never enables a tool, starts a service or hands out authority; lifecycle hooks run under an allow/ask/deny policy with their scripts pinned by hash.

03

Evidence, not claims

Packages define which checks and resources matter. The kernel runs the checks, observes the outcome and signs the receipt a guard requires — a plugin cannot certify its own claims.

Read the trust model

04 / Setups

Whole setups.
Signed and planned.

xis installs a complete setup — plugins, workflows, personas and a config profile — from a repository you pin yourself. Every artifact is content-addressed and the index is signed against the key you pinned, so a repository can never vouch for itself.

You see the whole plan first: every file written, kept, backed up or removed, and every environment value you must supply. Files apply with keep, backup or overwrite, and an ownership lock means an upgrade or removal touches only what the setup owns — a file you edited is reported and left alone unless you force it.

Plugin packages are delegated to praxis plugin install, so the kernel keeps its hooks policy, its lockfile and its trust store. What you must change afterwards lands in one change report: required environment, applied settings, backups and the exact praxis plugin trust commands. Secrets are never written and grants are never automatic.

How xis works
xisSetup sketch
# pin a repository and its signing key (your decision)
xis repo add standard https://getpraxis.boo/repo --key ed25519:…
xis search vim
xis plan    standard/[email protected]
xis install standard/[email protected]

# later: upgrade, or remove only what it owns
xis upgrade vim-states
xis remove  vim-states --keep-data
xis motd
xis.lock.jsonowned files · hashes · versions — your edits survive

05 / Your workspace

Work where you are.

Configure the runtime once. Talk to it through the interface that fits the task.

01 / Browser

A dashboard
for the details.

Chat, inspect context and tool history, configure secrets, manage plugins and view workflow state.

http://localhost:1337
02 / Terminal

Stay in
your terminal.

Use the chat TUI with local history, provider login, streaming answers and conversation controls.

praxis chat
03 / Discord

Bring agents
to your channels.

Connect an optional Discord bot for text and voice. Add QEMU VM tools and media plugins when needed.

Discord setup

06 / Get started

Your next agent
starts here.

Build with a recent stable Rust toolchain. Interactive onboarding prepares the installation assets and provider settings. Add optional capabilities as packages when you need them.

Read the setup guide
Build & start
git clone https://github.com/wasser-quest/praxis.git
cd praxis
cargo build --release --locked
./target/release/praxis install-preset compatibility --directory "$PWD"
./target/release/praxis onboard --interactive
./target/release/praxis run
Open the dashboard at http://localhost:1337.

Dashboard: 0.0.0.0:1337 · Gateway API: 0.0.0.0:3537. Use your server's hostname for remote access. Keep access behind your firewall, VPN or authenticated TLS proxy.

The standard preset

praxis install-preset compatibility --directory <install> fills in what a source checkout cannot ship: workflows, prompts, skills, dashboard files, the shipped plugin folders and the VM runtime assets. It installs public files only — never a service, a secret, a provider call or a tool flag. Upgrades add --update-dashboard (previous files are backed up) and a one-time --enable-vm-tools --data-dir <data> grants the VM tools. Then onboarding writes your settings and praxis run starts. Whole setups — plugins, workflows, personas and a config profile in one signed bundle — arrive with xis, its plan and its change report.

For verified coding

Select an existing project with praxis run --workspace-dir /path/to/project. Installation assets stay at ROOT_DIR. The runtime checks the prepared project before calling the model.

Project setup

07 / Install

Everything installable,
in one place.

Four kinds of installable, each with one obvious home — so nothing has to be guessed:

Frontends. The terminal UI and the dashboard are packages with installers. The TUI builds and places itself; praxis chat then finds it beside the kernel, on PATH, or where PRAXIS_TUI_EXECUTABLE points.
Tool packages. Shell, legacy file tools and vision build from source and place their binary and manifest into PLUGINS_DIR.
Tool & media plugins. The shipped folders install one at a time through the lifecycle — hooks policy, manifest validation, praxis.lock.json records — or with one preset command.
Assets & setups. Workflow, prompt and persona packs install like plugins; whole signed setups arrive with xis.

And what needs no install at all: the kernel-bundled packages — file_ops, runtime_control, memory, RAG, cron, Discord, interaction, skills, workflow authoring. praxis plugin builtins lists them.

Every install command
InstallWhat goes where
# terminal UI — then `praxis chat` finds and runs it
./scripts/install-tui-package.sh
praxis chat
# (beside the kernel, on PATH, or PRAXIS_TUI_EXECUTABLE)

# other frontends and tool packages
./scripts/install-dashboard-package.sh
./scripts/install-shell-package.sh
./scripts/install-legacy-file-ops-package.sh
./scripts/install-vision-package.sh

# tool & media plugins: one by one, or all at once
praxis plugin install ./plugins/brave_search
praxis plugin install-default --preset examples/presets/shipped-plugins.json

# asset packs and whole signed setups
praxis plugin install ./packages/asset_coding
xis install standard/[email protected]
PLUGINS_DIRone directory you can list, verify and remove