AC Astro Chicken
INIT
Init...

Astro Chicken Protocol

This dashboard visualizes the Astro Chicken protocol as a 3D system map on the left and contextual research cards on the right. Use it to explore axioms, problems, architectures, proofs, economics, governance, roadmap, and appendices.

00 // AXIOM

Objective Function

0x1A4F...SEED
-- Replication Rate (R)
-- Net Impact (Delta)

System Axiom: The protocol's objective function is to turn physical capacity into a self-compounding Replication Rate (R), enforced by a hard safety gate that ensures Net Impact (Delta) >= 0.

AXIOM PROCESS - HOW A FABNODE TURNS REAL-WORLD WORK INTO R, WITH Delta >= 0
1 // Physical Inputs
Capacity In
Hardware, capital, operators, environment.
->
2 // FabNode Cycle
Make -> Prove -> Learn
Each job produces service + Verifiable Performance Receipts (VPRs).
->
3 // Replication Engine
Replication Rate (R)
If R > 1, today's capacity builds tomorrow's extra capacity.
⇒
4 // Δ Gate
Net Impact (Delta)
If Delta < 0 -> rollout blocked. Only Delta >= 0 can be deployed and financed.
max R  subject to  Delta >= 0
R measures "capacity that creates new capacity". Delta encodes ecological and social constraints the protocol will never cross.
01 // CONTEXT

Ground Truth Drift

0x9B2C...ERR
--% Shadow Drift (Risk)
-- Sensor Density

The Drift Problem: "Shadow Drift" is the dangerous gap between what infrastructure actually does (Ground Truth) and what is reported in static dashboards. Astro Chicken collapses this drift using attested sensors.

GROUND TRUTH DRIFT - HOW IT EMERGES AND HOW ASTRO CHICKEN COLLAPSES IT
1 // Ground Truth
Real physical performance
Only one reality: actual flow, quality, uptime, energy use.
->
2 // Reported Data
Claims & dashboards
Invoices, spreadsheets, manual readings, opaque "black box" KPIs.
->
3 // Shadow Drift
Unverified deviation
The bigger the gap Ground Truth vs Reported, the higher the Drift and risk.
Drift = |Reported - Certified| / Certified
Without certification, "Reported" can drift arbitrarily far from reality, especially in low-sensor, low-audit environments.
4 // Instrumented Infra
TEE sensor mesh
Critical infrastructure is covered by attested sensors (Sensor Density (up)).
->
5 // Certified Stream
VPR groundtruth
Signed telemetry + outcomes become the only valid input for settlement.
->
6 // Drift Collapse
Shadow Drift -> 0
As Sensor Density and VPR coverage grow, the system drives Drift toward zero.
02 // ARCHITECTURE

Core Primitives

0x3D8E...ARCH
-- Active Nodes
-- Renewable Mix

Agent Mesh Architecture: Three primitives work in concert: the FabNode (Body) executes physical work, the Agent Mesh (Mind) plans and allocates resources, and the Learning Loop (Evolution) updates the system based on verified outcomes.

CORE PRIMITIVES - BODY (FABNODE) / MIND (AGENT MESH) / EVOLUTION (LEARNING LOOP)
FabNode // Body
Physical micro-factory
Converts Material & Energy into Services (e.g. water, power) and Parts for new FabNodes, with TEE attestation.
⇔
Agent Mesh // Mind
Planning & pricing layer
Takes Job Requests + SLAs, runs markets and schedulers, and emits Assigned Jobs + Prices for each FabNode.
^
Learning Loop // Evolution
Policy & design updater
Ingests Telemetry + VPRs and updates control policies, digital twins and hardware kits for the next generation.
Physical Rail
Material & Energy In -> Services & Parts Out
FabNode turns local inputs into certified services and components that can assemble new FabNodes.
->
Control Rail
Job Requests -> Assigned Jobs & Prices
Agent Mesh allocates jobs across nodes to maximize capacity utilization and keep SLAs green.
->
Learning Rail
Telemetry + VPRs -> Updated Kits & Policies
Learning Loop compresses real-world performance into better code, playbooks and bill-of-materials for replication.
Body: FabNode forms the physical capacity to act. Mind: Agent Mesh decides which actions to take where. Evolution: Learning Loop ensures each generation of nodes is cheaper, safer and more capable than the last.
03 // MECHANISM

The VPR (Verifiable Proof)

0x7F1A...VPR
--/hr Minting Rate
--% Invalid Proofs

Verifiable Proof (VPR): A VPR is a cryptographically signed receipt of physical work. It serves as both a settlement record for payments and a ground-truth label for training the AI models that run the mesh.

THE VPR - TRUTH MINTING PIPELINE (RAW TELEMETRY -> VPR -> LEDGER)
Step 1 // Raw Telemetry
Uncertified sensor stream
Time-series from FabNode sensors: flows, pressures, power, events, context. Still untrusted and off-ledger.
->
Step 2 // Attested Stream (TEE)
TEE-signed data
Hardware enclave signs the stream with device identity + integrity checks. Source becomes cryptographically attributable.
->
Step 3 // Rule / SLA Engine
Deterministic verdict
Compares the attested trace against SLA + safety rules. Emits a binary outcome: PASS / FAIL with full audit log.
->
Step 4 // VPR Mint
Verifiable Performance Receipt
If PASS, we mint a VPR:
VPR = (trace_window, outcome = 1, TEE sig, protocol hash).
->
Step 5 // Ledger / Settlement
Payout & reputation
VPRs settle into payouts, reputation updates, and risk models, on-chain or off-ledger, depending on the rail.
Fail Path
Rejected / Dispute Desk
If FAIL, the trace is flagged as rejected and routed to a dispute / investigation rail with full forensic context.
Data Window
Trace buffer per job
Each job produces a bounded trace_window (sensor values, controls, context) aligned to a contract interval.
->
Label
Binary outcome y in {0, 1}
The rule engine emits y = 1 if all constraints hold; otherwise y = 0. This is the perfect supervision signal.
->
VPR Dataset
(trace, y, sig) tuples
We obtain tuples (trace_window, y, TEE_sig) that become ground truth for AI training, underwriting and policy search.
Integrity: integrity ~ 1 - rejected / (accepted + rejected) VPR Supply: only PASS events mint settlement-ready, AI-ready ground truth.
04 // ECONOMICS

Value Capture

0x2C99...SCALE
--% Protocol Take Rate
-- Data Gravity

Token Dynamics: The protocol captures value via a thin fee on every Verified Transaction (VRT). We prioritize network density and data gravity over high margins, ensuring value flows primarily to operators and communities.

VALUE CAPTURE - VERIFIED FLOW OF FUNDS & SCALING LAWS
Flow 1 // End-User Payment
Job request + payment intent
An end-user requests a physical service (e.g. water, energy, repairs) and commits funds into a conditional payment rail tied to future VPRs.
->
Flow 2 // Verified Transactions (VRT)
VPR-backed transaction volume
Each settled VPR becomes one Verified Transaction (VRT). Let VRT(t) be the number of VRTs over a time window t.
->
Flow 3 // Fee Split on VRT
Thin take rate Ï„ on VRT(t)
A small fraction Ï„ = takeRate on each VRT funds the protocol, while the majority of value is routed to operators and communities.
Split A // Protocol
Ï„protocol
Funds core services, risk models, reference infra. Typically the smallest slice of Ï„.
Split B // Operators
Ï„operators
Pays FabNode operators for running jobs and maintaining hardware, directly tied to their VPR/VRT output.
Split C // Community / Buffers
Ï„community
Funds local resilience pools, maintenance reserves, and shared risk buffers around critical infrastructure.
Law 1 // Throughput
VRT(t) ~ nodes(t)gamma
As the number of active FabNodes nodes(t) grows, verified throughput scales superlinearly with exponent gamma > 1.
Law 2 // Cost Curve
unit_cost(t) ~ output(t)-b
With cumulative verified output output(t), unit cost falls along a learning curve with b > 0, driven by VPR data.
Law 3 // Revenue
Revenue(t) = VRT(t) × fee_per_VRT
Revenue grows with VRT volume and a thin fee fee_per_VRT ~ tau * avg_ticket_size, not with increasing margins.
Truth-Yield: As VPR volume and data integrity grow, underwriting risk (down) and the value of the dataset (up). The protocol sells certainty, not extraction. Data Gravity: networkVal reflects how cumulative VPR/VRT volume pulls in capital, jobs and models into the Astro Chicken ecosystem.
05 // GOVERNANCE

Sovereignty

0x5A00...DAO
--% Safety Compliance
-- Open Proposals

DAO Governance: Sovereignty resides with local communities and Nature. Every rollout is gated by a verifiable Net Impact (Delta) check. If Delta < 0 (harmful), the protocol automatically blocks deployment.

SOVEREIGNTY - HOW DELTA-GATES, GUARDIANS AND NATURE CONTROL ROLLOUTS
Input // Field Signals
Proposals, incidents & telemetry
Local operators, sensors and community members emit job proposals, alerts and impact reports tied to specific infrastructure (water, energy, mobility...).
->
Layer 1 // Local Guardians
Community & operator council
A set of local guardians (operators, elders, committees) review proposals and incidents against local norms and lived context before escalation.
->
Layer 2 // Δ-Gate Engine
Policy & impact evaluation
A policy engine evaluates each rollout against ecological, social and safety constraints, producing a Net Impact score Delta. Only Delta >= 0 may continue.
Outcome A // Allowed Rollout
Delta >= 0 -> deploy
If Delta >= 0 and safety compliance is high, the rollout is authorized and pushed to the Agent Mesh + FabNodes for execution under continuous monitoring.
Outcome B // Block & Redesign
Delta < 0 -> veto
If Δ < 0 or risk exceeds thresholds, the rollout is blocked and sent back to planning / design, preserving a full audit trail of who proposed what and why it failed.
Rail 1 // Identity & Ownership
Local data, minimal disclosure
Identities and datasets remain owned locally. Federated learning, ZK / Min-Info proofs and scoped keys ensure that only the minimum information needed to evaluate Δ leaves the community.
Rail 2 // Accountability
Immutable trails & drills
All governance actions emit immutable decision logs, red-team drills and incident reviews. This makes it possible to replay how Δ was computed for any rollout.
Rail 3 // Nature as Stakeholder
Environmental veto power
Environmental limits (water tables, emissions, biodiversity indices) enter as hard constraints in the Δ-Gate. Nature effectively gains veto power over harmful deployments.
Compliance (%): Tied to safety logs and policy checks; when high, the guardian shield in the 3D view is stable and coherent, and Δ-Gates rarely block. Open Proposals: Counts the active items in the proposal storm around the governance shell, representing how much decision load the system is currently processing. Guardian Ring & Storms: The 3D governance visualization mirrors this diagram: guardians form the shield, alignment halo reflects Δ health, and proposal/incident storms show governance pressure on the mesh.
07 // IMPLEMENTATION

Verifiable Roadmap

0x8B11...TIME
-- Current Phase
--% Phase Completion

Implementation Roadmap: We follow a finite, verifiable path from a single Seed Node to a self-replicating cohort (R >= 1). Progress is measured in verified milestones, not arbitrary dates.

FROM SEED TO REPLICATION COHORT - TIME x SCALE x RISK
Lane 1 // Time Phases
Phase 0 // T+0
Seed / Local Pilot
One seed FabNode deployed in a single region. Goal: prove the full request->make->deliver->verify loop under stress.
->
Phase 1 // T+90 Days
Operational Pilot
Multiple jobs run with traceable QA on water infrastructure. Success: sustained Net Delta >= 0 and stable on-site operations.
->
Phase 2 // T+180 Days
Network Activation
A small Agent Mesh goes live with public SLAs and a catalog of infrastructure kits. Jobs are scheduled across multiple FabNodes.
->
Phase 3 // T+12 Months
Replication Cohort (R >= 1)
A cohort of nodes in at least 3 dense regions reaches a replication rate R >= 1: capacity builds new capacity at steady state.
->
Phase 4 // Beyond
Planetary Rollout
Scaling along tested patterns: new regions onboard using the same verifiable playbook with bounded risk.
Lane 2 // Scale & Replication
Metric // Nodes
Nodes Now vs Nodes Target
Each phase has a node target (Nodes Target) and an observed installed base (Nodes Now). The 3D view shows: current swarms (Now) vs target swarms (Target) along the arc.
Condition // Replication Rate
R >= 1 -> cohort is self-sustaining
The roadmap becomes locked in once a region cohort reaches R >= 1: new FabNodes can be financed directly from verified cashflows and Truth-Yield, not speculative promises.
Lane 3 // Risk Band
Roadmap Risk
Risk band over future phases
A risk score tracks how much unproven complexity we are adding ahead of the current phase. In the 3D view this appears as red clouds over the future part of the arc.
Constraint
Do not outgrow proofs
The system avoids adding nodes faster than we add proven VPR data. Scale is allowed only when evidence (Delta >= 0, stable VPR pipeline) matches the desired growth rate.
Current Phase: Encodes which of the phases (Seed, T+90, T+180, T+12, Beyond) is active. In the 3D arc, this is the highlighted phase node marked as "Now". Phase Completion (%): Measures how far we are inside the current phase. Internally can map to phaseIndex, totalPhases and an intra-phase completion metric. Nodes & Risk: currentNodes and nodeTarget feed the "Now vs Target" swarms, while riskScore controls the density of red risk clouds along the arc, matching the Risk Band lane in this diagram.
08 // APPENDIX

Frontier Labs

0xFFFF...END

Frontier Labs: This card is the launch workspace for Astro Chicken. Each option below is one slice of the stack we ship: the CLI agent, the model + training bundle, and the FabNode edge slice.

LAUNCH STACK // PICK ONE SLICE TO INSPECT
Click one of the three slices below to inspect its spec and checksum. The buttons correspond to:
  • Astro Chicken CLI // Tech Preview (CLI): one terminal command, local or cloud AI. Start here.
  • Model & Training // Unsloth Stack (MODEL): datasets, LoRA adapters and eval artifacts.
  • FabNode Edge Slice // Pi + OctoPrint (EDGE): minimal but real FabNode slice for printers and pumps.
// Select a slice (CLI, MODEL, or EDGE) to view specs and checksum
How to use this space: Pick one of the three slices above. The selected option updates the Selected Core block and determines what the Astro Chicken Core Bundle represents for this run. What the bundle represents: A cohesive kit wired to this dashboard: CLI profile, model/training configuration and edge slice recipe. Only slices that satisfy Delta >= 0 and pass safety checks graduate from Frontier Labs into the main roadmap.