praxis

The process by which a theory, lesson, or skill is enacted, embodied, realized, applied, or put into practice.

---

---

description

The Praxis platform is an ever-evolving, local-first, peer-to-peer, burstable, flexible, modular, extensible and decentralized framework for the practice of computational alchemy. We are building a multi-modal fleet of AI agents that are small and simple, easy to parallelize, fault-tolerant, portable, and performant at any scale. We will achieve this via identity-weighted multipath routing, symbolic decision-making and prayer (asynchronous).

features

Praxis is organized as 52 pluggable registries. The feature categories below link to a docs page listing the concrete implementations and their source. See docs/index.md for the full map.

• Activation functions (35)
• Attention mechanisms (13)
• Block-stacking decoders (4)
• Data sampler strategies (6)
• Decoder block layouts (9)
• Feedforward experts (10)
• Halting / early exit (2)
• Input encoders (26)
• Layer-routing controllers (8)
• Long-term memory (9)
• Loss functions (11)
• Mixture-of-widths (7)
• Mono-forward graph cutting (3)
• Normalization layers (5)
• Optimizer profiles (7)
• Optimizer wrappers (8)
• Output heads (16)
• Positional encoding (5)
• Recurrent cells (2)
• Residual connections (4)
• RL policies (7)
• Sequence compression (3)
• Sequence sorting (5)
• Token embeddings (15)
• Token routers (15)
• Training strategies (4)
• Training-loop governors (1)

layout

Top-level directories, with detail sourced from each one's README where present.

• axis/ - A home for random side projects that live in the Praxis repo but have little or no integration with it. Each subdirectory is a self-contained app with its own toolchain (Godot, Kotlin, ...); Praxis neither imports them nor depends on them. They live here because this is where the work happens, not ...
• docs/ - Auto-generated per-registry docs. Regenerated at every launch.
• environments/ - Environment configurations override all other settings (defaults, experiments, and CLI args) to provide controlled presets for different use cases.
• evaluation/ - Evaluation harnesses and helpers.
• experiments/ - This directory contains experiment configurations for Praxis. Each .yml file defines a preset combination of CLI arguments.
• integrations/ - This directory contains optional integrations that extend Praxis with additional functionality. Each integration is self-contained and can be automatically loaded based on CLI flags or conditions.
• next/ - Long-form research notes, exploratory writing, and the project roadmap.
• praxis/ - The model framework itself. See docs/index.md for the per-registry feature map.
• research/ - The research paper, in LaTeX.
• staging/ - Welcome to the junkyard! This is where we dump experimental code that doesn't belong in core Praxis.
• static/ - Images used in the README and the web dashboard.
• tests/ - Unit tests. Run with pytest tests -x.
• tools/ - A shared toolbox of small CLI utilities, callable directly by both the human and the assistant (and, eventually, by Praxis models at inference time) so neither side has to relay numbers off charts or read/copy/paste data between contexts. Each tool is single-purpose and runs as `python ...

subsystems

Standalone subsystems, documented outside the registry map.

• CLI arguments - every ./launch flag, grouped as in --help.
• Web stack - dashboard, JSON API routes, and inference endpoints.
• ghost - spectral audio visualizer and video masking editor (Godot, standalone), with its own generated reference under axis/ghost/docs/.
• Vortex mobile app - archived Godot companion app for controlling Praxis.
• nuTube - local-first YouTube explorer with an on-device recommender (Godot, in development).

installation, configuration, and usage

commands

The launch script will automatically manage the virtual environment. To start, simply run:

./launch

To view all supported command-line arguments:

./launch --help

Every flag is also catalogued in docs/cli.md, auto-generated from the parser on each launch.

For development with quick iteration:

./launch --dev --no-dashboard

To run inside Docker (auto-detects ARM vs x86_64; forwards all subsequent flags):

./launch compose --alpha

To tear a running compose stack back down:

./launch stop

To run unit testing (accepts pytest arguments):

./launch test -x

recommendations

We recommend you use a batch-size of at least 16, if possible. Batches periodically trade size for sequence length: a sequence multiplier of 2x, 4x or 8x divides the batch size by the multiplier squared, keeping token count constant. Each tier unlocks when batch-size reaches the multiplier squared (4, 16, 64).

We also recommend using an Nvidia GPU.

./launch --batch-size 16 --device cuda

To apply alpha settings to your experiment:

./launch --alpha

To apply dev settings within your environment, with device overrides:

./launch --alpha --dev --device cuda:8 --quiet

use with transformers

PraxisForCausalLM is a real PreTrainedModel + GenerationMixin, so once registered, any Praxis checkpoint works with the transformers Auto* classes:

from transformers import AutoModelForCausalLM, AutoTokenizer
from praxis import PraxisConfig
from praxis.trainers import register_praxis_models

register_praxis_models()

config = PraxisConfig(
    embed_size=512,
    hidden_size=384,
    depth=6,
    num_heads=8,
    device_map="cuda:0",
)

tokenizer = AutoTokenizer.from_pretrained("UNSAFE/praxis-4096")
model = AutoModelForCausalLM.from_config(config)

input_ids = tokenizer.encode("The quick brown fox ")
outputs = model.generate(input_ids, do_sample=True)

print(tokenizer.decode(outputs[0], skip_special_tokens=True))
# --> The quick brown fox jumped over a lazy dog.

showcase

web stack

The dashboard and chat interface live at http://localhost:2100, backed by a JSON API for inference, metrics, and run management. See docs/web.md for the architecture, the full route table (auto-generated from the live Flask app), and Python examples for the /input and /messages endpoints.

The Terminal tab streams the live training dashboard - error and validation, the rolling sampled-context blocks, the system panel, and the loss curve:

The Customs tab inspects the instantiated model. Its Architecture card renders the full module tree, so the registry choices for a run are legible at a glance (shown here for a --beta model: byte-latent encoder, Arc attention, KL-divergence halting):

side projects

The axis/ directory holds standalone side projects that live in this repo but have little or no integration with Praxis. It currently contains Vortex, an older Godot app for controlling Praxis, and nuTube, an experiment in a local-first YouTube recommender that runs entirely on the device.

won't do

• cryptocurrency

community

• Demo
• Discord
• Youtube
• The Source

limitations

• You will quickly run into rate limits with the Huggingface Datasets API. This is because anonymous users tend to be bots, and are subjected to severe restrictions. To alleviate this problem, you can install huggingface-cli, and authenticate with a real user account. Praxis will use this user automatically.