Roadmap
URUZ VM is progressing through disciplined technical milestones. Each phase builds on stable foundations while the broader URUZ stack matures. This is engineering sequencing, not marketing projection.
Technical Progression
Each milestone represents a stable increment in capability. Progress is sequential and deliberate.
Local / Devnet Bring-Up
Establish runtime loops, health, state inspection, and operational surfaces.
Real Execution Path
Integrate Aptos-backed execution reads, events, mint submit/simulate, and burn flow handling.
Real Settlement Read Path
Integrate Kaspa-backed settlement reads, finality observation, upstream provider path, and normalized backend facade.
Recovery Hardening
Add replay-safe recovery, transient-failure handling, and better operational confidence.
Release Primitive Boundary
Separate read path and release path cleanly, define release service boundary, wallet boundary, and idempotent release handling.
Real Release Primitive
Move from local/mock release boundary toward a real Kaspa-backed release primitive.
URUZ Devnet Integration
Replace temporary assumptions with real URUZ devnet data and contract surfaces.
Current Status
A clear view of what is done, what is in progress, and what comes next.
Complete
Stable and operational
- Runtime loop architecture
- Health monitoring surfaces
- State inspection tooling
- Local devnet environment
- Operational observability
In Progress
Active development
- Aptos execution integration
- Event stream processing
- Mint flow validation
- Burn flow handling
Next
Queued for development
- Kaspa settlement reads
- Recovery hardening
- Release primitive boundary
- Real release integration
- Full devnet integration
Progress Guided by Principles
Roadmap advancement follows structural constraints, not speed targets. These principles shape every milestone.
Define clean separation before adding complexity. Boundaries prevent coupling that becomes debt.
Instrument before scaling. You cannot debug what you cannot see.
Canonical flow states before branching logic. Clear mappings prevent silent divergence.
Coordination stays outside contracts. Contracts hold state, not process.
Every cross-layer dependency is explicit. Hidden dependencies create hidden failures.
These are not aspirations. They are active constraints that determine what gets built and in what order.
Why This Sequencing
The order is intentional. Each dependency is acknowledged. Rushing breaks things that are expensive to fix.
Observability Before Scale
Infrastructure must be instrumented before it is stressed. Without observability, scaling is guessing.
Read Paths Before Automation
Real read paths should stabilize before deeper automation layers are added. Stable inputs produce stable outputs.
Recovery Before Maturity Claims
Reconciliation and recovery matter before claiming production readiness. Systems fail—maturity is how they recover.
Clean Boundaries During Integration
Contract boundaries should stay clean while integrations deepen. Coupling creep is the enemy of maintainability.
This sequencing reflects engineering reality, not investor timelines. Each phase exists because the previous one makes it possible.