PRAXIS is a voice-to-code multi-agent platform built in Rust. You speak an intention, it is transcribed locally, an orchestrator turns it into a strict validated DSL plan, and a guardrailed executor runs each task with real sandboxed compile checks and human approval.

Does PRAXIS send my voice or code to the cloud?

Voice transcription runs locally through whisper.cpp behind a Transcriber trait, so audio never leaves the machine. LLM providers are local-first with cloud strictly opt-in per run.

How does PRAXIS prevent broken AI-generated code?

Every task's generated code is compiled in an isolated throwaway sandbox crate with a real cargo check and a dependency allowlist. Compiler errors feed bounded repair loops - at most 3 attempts - and each task requires human approval before proceeding.

What are PRAXIS guardrails?

A dedicated guardrails engine checks every action against typed project policies parsed from instructions.md tables - covering project visibility and per-project rules - and returns an explicit verdict before anything executes.

What is the PRAXIS DSL plan format?

A four-section serde-typed contract: Objective, Dependencies, Logic, and Success Criteria. Validation collects all errors at once and tasks are ordered with a deterministic, stack-safe Kahn topological sort.

← Infinity Tech Stack

▲

PRAXIS

Speak the chaos. Ship the code. A voice/text brain-dump gets compiled into a strict, validated DSL plan — then executed by sandboxed Rust agents that genuinely compile their own work and self-repair before you ever see it. One reviewable task at a time.

Rust 2024Guardrailed PrivacyLocal-First LLMsSandboxed AgentsADHD-Native UX35 Tests · 0 Warnings

*unsafe_code = "forbid" across the entire workspace

VOICE TO DSLSPEAK YOUR INTENTIONSTRICT DSL SCHEMATOPO-SORTED TASKSPRIVACY GUARDRAILSGIT-PUSH ENFORCEMENTSANDBOXED CARGO CHECKSELF-REPAIR LOOPONE TASK AT A TIMERIG-CORE MULTI-PROVIDERWHISPER.CPP LOCALZERO UNSAFE CODE35 TESTS GREEN2,556 LINES OF RUSTCLIPPY CLEANVOICE TO DSLSPEAK YOUR INTENTIONSTRICT DSL SCHEMATOPO-SORTED TASKSPRIVACY GUARDRAILSGIT-PUSH ENFORCEMENTSANDBOXED CARGO CHECKSELF-REPAIR LOOPONE TASK AT A TIMERIG-CORE MULTI-PROVIDERWHISPER.CPP LOCALZERO UNSAFE CODE35 TESTS GREEN2,556 LINES OF RUSTCLIPPY CLEAN

Lines of Rust

Crates

Tests Passing

Clippy Warnings

Unsafe Blocks

📊

Kahn Topo-Sort Dependency Graph

DAG Matrix

Deterministic Kahn Topo-Sort DAG Graph

Task 1: Schema

praxis-dsl · 244 LOC

Serde-typed YAML validation & deterministic Kahn topo-sort.

💻

Interactive CLI & Engine Terminal

Live Simulator

praxis-cli v0.1.0

[SYSTEM]Running Praxis Environment Health Check...
[WHISPER]whisper.cpp (local ggml-medium.bin) → OK (0.0ms latency)
[RUSTC]rustc 1.88.0 (2024 edition) → OK
[POLICY]instructions.md loaded → 4 restrictions derived
[CARGO]cargo-check sandbox runner → OK (0 unsafe blocks)
[DOCTOR]All 6 crates operational. 35/35 tests passing green.
PS C:\praxis>

🔀

Five Stages, One Direction

Click a stage

→

🎙 Voice-to-Context — bypass the hands — `praxis-voice`

Record a raw stream of consciousness as WAV; a Transcriber trait turns it into text. Local whisper.cpp transcription is one feature flag away and nothing ever leaves the machine.

Transcriber trait — swap engines without touching callers
whisper-local feature — whisper.cpp + ggml model on disk
Graceful degradation — text input works while voice is set up

🛡

Privacy Enforced In Code

Live playground

PRAXIS parses a Project / Visibility / Rule table straight from an ecosystem's own instructions files and derives typed restrictions at load time. Every git push, deploy, or cross-project write gets a typed verdict before it runs. This playground runs the exact same verdict logic as the Rust engine:

Project

Action

PS> praxis guard --project "Neuromantix" --action push

DENY

Neuromantix is PRIVATE — rule: “NO git. Never push, commit, or expose anywhere.” Git push is blocked.

Project	Visibility	Derived restrictions
Infinity	PRIVATE	no_git_push · vercel_only · no_public_repo
Neuromantix	PRIVATE	no_git · no_public_repo
Void	PRIVATE	no_public_repo
Vitalis	PUBLIC	—

📐

A DSL, Not a Language

Hover the cards

LLMs hallucinate in Python. They can't hallucinate past a serde schema. Every brain-dump is compiled into this strict YAML — invalid plans get their batched validation errors fed back for auto-repair, max 3 rounds.

plan.yaml — validated by praxis-dsl

name: auth-system
project: my-app
objective: "JWT auth on Postgres; survive token
  expiry mid-websocket"
dependencies:
  - jsonwebtoken
  - sqlx
tasks:
  - id: 1
    title: "Design sessions schema"
    agent: schema
    logic: "users + sessions tables,
      refresh-token rotation"
    success_criteria: "migration applies
      cleanly; cargo test schema:: green"
  - id: 2
    title: "JWT middleware"
    agent: backend
    depends_on: [1]  # topo-sorted, cycle-checked

[Objective]

One paragraph defining “done”. Empty → plan rejected before any agent runs.

[Dependencies]

Explicit externals only. The sandbox refuses unlisted crates — a hallucinated dependency can't smuggle in a build script.

[Logic]

Precise instructions per task. Small on purpose: one reviewable chunk for one specialized agent.

[Success Criteria]

Objectively checkable. Feeds the compile-check + self-repair loop its definition of green.

⚡

Agents That Fix Themselves

Press play

Each task is staged into an isolated throwaway crate and genuinely compiled — cargo check runs inside the sandbox, bounded by a timeout. Compiler errors go straight back to the agent. You only ever review code the compiler already vouched for.

🤖

agent writes

📦

sandbox stage

🦀

cargo check

🔧

self-repair

👤

you: y/N

Press ▶ simulate to watch one task travel the loop.

📦

Module Inventory

Verified LOC

lib.rs · executor

Executor::run_plan() — dependency-ordered task loop, guardrail gate293

plan.rs · dsl

Plan validation (batched errors), deterministic Kahn topo-sort244

policy.rs · guardrails

ProjectPolicy + typed Restrictions derived once at parse time222

sandbox.rs · executor

Isolated throwaway crates — real cargo check, dependency allowlist216

engine.rs · guardrails

Guardrails::check(Action) → Verdict — the enforcement point134

lib.rs · guardrails

Public façade + PolicyRegistry loading from instructions.md125

extract.rs · agents

Fenced code-block extractor — language-aware, multi-block picker122

lib.rs · voice

Transcriber trait + feature-gated whisper.cpp local backend117

config.rs · cli

praxis.toml loading — guardrails, provider, executor settings111

orchestrator.rs · agents

Transcript → validated Plan — error-fed retries, max 3 rounds104

task.rs · dsl

Task, AgentRole enum with Custom(String) untagged fallback99

markdown.rs · guardrails

Project/Visibility/Rule table parser — strips bold/code/links97

report.rs · executor

PlanReport — outcome, repair count, check status per task93

cli.rs · cli

clap subcommands — doctor, plan, run, guard88

prompts.rs · agents

DSL spec + repair prompt builders — batched validation errors84

code_agent.rs · agents

Task → GeneratedCode + repair() from compiler output78

🧠

Built For How Brains Actually Work

ADHD-native

🎙

Bypass the hands

Local whisper.cpp transcription. Pace the room, ramble — the orchestrator sorts it out. Zero cloud.

🧩

One chunk at a time

The approval gate shows exactly one task. Yes or No. Working memory stays free for judgement, not juggling.

🛑

Bounded everything

Max 3 plan-repair rounds, capped code-repair rounds, check timeouts. No infinite loops, no runaway spend.

🔒

Privacy is compiled in

Guardrails parse your own rules file — git push on a private repo is a typed Deny, not a hope.

🦀

Compiler = reviewer #0

Bad Rust never reaches your eyes. unsafe_code = "forbid" across the whole workspace.

🔌

Local-first LLMs

Local models by default; Claude / OpenAI opt-in per run via one flag. Provider is config, never architecture.

⚙

Core Dependencies

Cargo

rig-corev0.40

Provider-agnostic LLM agents — one trait, many backends

whisper-rsv0.16

Local whisper.cpp bindings — feature-gated, zero cloud

serde_yaml_ngv0.10

Maintained YAML parser for the strict DSL schema

tokiov1.52

Async runtime — sandboxed cargo check with timeouts

thiserrorv2.0

Typed, structured errors across every crate boundary

clapv4

CLI — doctor, plan, run, guard subcommands

regexv1.13

Markdown table parsing for the guardrails engine

PRAXIS · private workspace, public overview only · runs fully local by default