FRAME is a local-first, deterministic runtime for applications and agents. It executes user intents through a capability-constrained execution engine, producing cryptographically signed receipts that enable verifiable state reconstruction and integrity verification.

Instead of traditional apps directly mutating state, FRAME processes intents through a deterministic kernel that:

• Resolves intents to dApps
• Executes dApps inside a capability-scoped API
• Records executions as cryptographically linked receipts
• Recomputes a deterministic state root representing the entire system state

All application behavior is verifiable, replayable, and deterministic.

• Architecture Overview - High-level system architecture and layers
• Core Principles - Foundational invariants and design philosophy
• Directory Structure - Repository layout and file organization

• Runtime Pipeline - Intent execution flow from user input to receipt
• Kernel Runtime - Deterministic runtime core, protocol versions, integrity locks
• Deterministic Execution - Sandboxing rules, replay guarantees
• Router and Intents - Intent resolution, manifest scanning, dApp dispatch

• Capability System - Capability declaration, grants, and enforcement
• dApp Model - dApp structure, manifests, module execution

• Storage Model - Canonical JSON storage and validation rules
• Receipt Chain - Execution receipts, signing, chain linking
• State Root - Deterministic state root computation
• Replay and Verification - Deterministic replay and state validation
• Snapshots and Backups - State export/import and recovery
• Execution Proofs - Verifiable execution proofs and trace recording

• Identity and Vaults - Multi-identity system, Ed25519 keys, vault isolation
• Threat Model - Security guarantees and trust assumptions

• AI System - Intent parsing, classification, UI planning
• Composite Execution - Multi-step intent execution, rollback behavior
• Agent System - Agent registry, lifecycle, automation
• Capsule System - Portable execution units, workflow chaining
• UI System - Widget-based UI, layout management, adaptive planning

• Networking Model - Deterministic network requests, response sealing
• Federation and Sync - Receipt chain export, state synchronization
• Attestations - Cryptographic state proofs and cross-instance verification
• Distributed Execution - Deterministic distributed execution (DDE) and compute tasks

• Wallet and Bridge - frame tokens, escrow, bridge mint/burn mechanics
• Contracts and Escrow - Contract lifecycle, proposals, signing

• FRAME Protocol Spec - Single source of truth for protocol constants and schemas
• Protocol Versions - Version constants and compatibility

• Runtime Invariants - All invariants that must always hold
• Test Coverage - Test coverage mapping and missing tests
• Integration Flows - How modules connect and interact
• Failure Modes - All possible failures and recovery
• Protocol Compliance Checklist - Developer audit checklist
• Debugging Guide - How to debug runtime issues
• Formal State Machine - Pure state machine correctness model
• Boot Sequence - Exact startup order and verification

• Glossary - Key terminology and definitions
• Documentation Plan - Complete documentation roadmap

1. Read Architecture Overview for the big picture
2. Review Core Principles to understand invariants
3. Follow Runtime Pipeline to see how intents execute
4. Explore Capability System to understand dApp permissions

FRAME uses frozen protocol versions for compatibility:

• PROTOCOL_VERSION: 2.2.0 - Overall protocol version
• RECEIPT_VERSION: 2 - Receipt format version
• CAPABILITY_VERSION: 2 - Capability taxonomy version
• STATE_ROOT_VERSION: 3 - State root computation version

These versions define compatibility across FRAME nodes. See Protocol Versions for details.

These principles must always hold:

1. Deterministic Execution - Same receipt chain always produces same state root
2. Canonical Data Model - All persisted state is canonical JSON
3. Cryptographic Receipts - Every state transition produces a signed receipt
4. Capability-Based Isolation - dApps only access declared capabilities
5. Immutable Runtime Surfaces - Kernel interfaces frozen after boot
6. Verifiable State Root - Hash over canonicalized system state
7. Replay Verifiability - State reconstructible from receipt chain
8. Local Sovereignty - All execution occurs locally

See Core Principles for detailed explanations.

Join in shaping the post-human digital operating system: 👉 https://discord.gg/k7K4FwQpyf

MIT License — see LICENSE.md

FRAME is a vision protocol — a reference operating structure for digital sovereignty. It belongs to no one. It evolves through logic, not authority.