Quickstart

This walks you from an empty machine to a live, end-to-end OGONG mesh running locally: providers committing work, validators auditing it, and quorum-gated settlement on a local Solana test validator. Everything is CLI, no GUI.

If you just want to serve a model with zero network and zero signup, skip to Local mode.

0. Prerequisites

• Rust (stable) and cargo.
• Solana CLI + Anchor (for the on-chain program and the local test validator).
• Node + npm (the mesh provisioning scripts are TypeScript).
• A model file for whichever modality you’re serving (e.g. a .gguf for text, or the ACE-Step audio model used by the live mesh demo).

1. Build the binaries

From the repository root:

# Validator + verifier (settlement feature enables on-chain settle)
cargo build --release --features settlement \
  -p validator-service --bin ogong-validatord --bin ogong-verifierd

# Router marketplace + consumer gateway
cargo build --release -p ogong-router-service --bin ogong-routerd --bin ogong-gatewayd

# Provider daemon
cargo build --release -p ogong-provider

The resulting binaries land in target/release/. Add it to your PATH or call them by full path.

2. Run the whole mesh with one script

The fastest way to see OGONG work end-to-end is the bundled mesh runbook. From llamamp/chain:

# Stage 1 - registry-driven discovery
bash scripts/run-mesh-stage1.sh

This brings up a local solana-test-validator, deploys the chain program, launches several ogong-validatord instances, stakes and registers each one on-chain with its real QUIC endpoint and cert, and then confirms every node discovered the others purely from the on-chain registry, with no manual peer wiring.

# Stage 2 - quorum settle over real QUIC
bash scripts/run-mesh-stage2.sh

Three validators; one holds the settlement role. A metered release is pushed, the handling node gathers the peers’ co-signatures over QUIC, and submits the on-chain quorum settle. Verified by the provider’s fee account balance increasing.

# Stage 3 - audit-gated settle, backed by a real engine
# (terminal 1) bring up the reference engine in commit mode:
LLAMAMP_COMMIT=1 llamamp-audio-server \
  -m ~/models/ace-step-v1-3.5B/ace-full-f16.gguf \
  --vocab ~/models/ace-step-v1-3.5B/vocab.json --port 11436
# (terminal 2) run the capstone:
bash scripts/run-mesh-stage3.sh

Stage 3 is the full thing: a real generation is audited before its escrow releases, and only an Accept settles. See The local mesh for exactly what each stage does.

3. Or wire the pieces by hand

To understand the moving parts, run them individually:

# A validator that audits every reply and dispatches to a verifier
ogong-validatord \
  --bind 0.0.0.0:4533 \
  --alpha 1 \
  --verifier-endpoint 127.0.0.1:4544 \
  --verifier-cert /path/to/verifier.der

# The verifier, pointed at an independent engine instance
ogong-verifierd \
  --bind 0.0.0.0:4544 \
  --provider-url http://127.0.0.1:11436

# The marketplace match engine (writes its cert so a gateway can pin it)
ogong-routerd --bind 0.0.0.0:4544 --cert-out router.der

# The OpenAI-compatible consumer front door
ogong-gatewayd --bind 0.0.0.0:4546 --router 127.0.0.1:4544 --router-cert router.der

# A provider serving an embedded text model and joining the network
ogong-provider configure \
  --embedded-text /path/to/model.gguf \
  --join-network \
  --validator-endpoint 127.0.0.1:4533
ogong-provider start

4. Call it

Once a gateway is up, talk to the network through any OpenAI-compatible client:

curl http://127.0.0.1:4546/v1/chat/completions \
  -H 'content-type: application/json' \
  -d '{
    "model": "ogong/verified/<maker>/<model>",
    "messages": [{"role":"user","content":"Hello from OGONG"}]
  }'

See the Consumer API for the model-id format and supported endpoints.

Next

• Provider node - every provider mode and flag.
• Validator node - audit rate, peers, settlement.
• The local mesh - a stage-by-stage tour of what the scripts do.