---
title: README
emoji: 📊
colorFrom: blue
colorTo: blue
sdk: static
pinned: false
---
# FRAME

FRAME is a local first deterministic runtime for AI driven applications, identity, and execution.

## What it is

FRAME turns natural language into structured, verifiable actions. Instead of generating open ended text, AI inside FRAME produces low entropy, constrained outputs that execute directly against a capability scoped system. Every action is processed as an intent, routed through a deterministic kernel, and recorded as a cryptographically signed receipt.

The result is a system where AI behavior is reproducible, replayable, and provably correct.

## Core Principles

Deterministic execution  
All actions resolve to the same outcome given the same inputs and state  

Low entropy AI  
Models produce structured outputs instead of freeform text  

Verifiable state  
Every operation is recorded as a signed receipt and contributes to a state root  

Capability isolation  
AI and applications can only access explicitly granted system capabilities  

Local first  
Runs on user owned hardware with no dependency on centralized servers  

## AI and ML Focus

FRAME uses a distilled local model exported as GGUF that is trained to emit a constrained intermediate representation instead of natural language. This model acts as an intent compiler, converting user input into structured, deterministic commands that can be directly executed by the runtime.

Key areas include

Distillation into a low entropy intermediate language  
Grammar constrained decoding for deterministic outputs  
Local GGUF inference for offline execution  
Tight coupling between model outputs and execution engine  
Validation and canonicalization of every generated action  
Replayable model behavior through structured outputs  

## Model

Current model is exported as GGUF for efficient local inference and integration with lightweight runtimes.

Purpose of the model

Translate natural language into structured intent representations  
Enforce deterministic and valid output formats  
Minimize ambiguity and eliminate freeform generation  
Act as the entry point for all AI driven execution inside FRAME  

## Efficiency Comparison

| Metric | Typical Small Browser Model | FRAME GGUF Intent Model |
|--------|---------------------------|-------------------------|
| Output Type | Freeform text | Structured intermediate representation |
| Tokens per task | High and variable | Minimal and predictable |
| Inference passes | Multiple retries often required | Single pass deterministic |
| Error rate | Higher due to ambiguity | Near zero with validation |
| Post processing | Heavy parsing and cleanup | None or minimal |
| Latency | Slower due to retries and parsing | Faster due to direct execution |
| Compute usage | Wasted on irrelevant tokens | Focused on actionable output |
| Memory footprint | Larger active context | Reduced due to compressed format |
| Determinism | Non deterministic outputs | Fully deterministic outputs |
| Execution readiness | Requires interpretation | Directly executable |

Estimated impact

2x to 5x fewer tokens per task  
1.5x to 3x faster end to end execution  
Significantly reduced failure and retry overhead  
Near zero ambiguity in output interpretation  

## Architecture Overview

User input is converted into an intent via the GGUF model  
The kernel routes the intent to a scoped application  
The application executes using only allowed capabilities  
The result is committed as a signed receipt  
The system recomputes a deterministic state root  

All steps are traceable and can be replayed exactly.

## Why it matters

FRAME enables AI systems that do not just respond but act with guarantees. By combining a constrained local model with deterministic execution and cryptographic verification, it removes ambiguity and makes outcomes provable.

## Use Cases

Personal AI operating environments  
Financial automation and verifiable transactions  
Local first applications with full user control  
Agent driven workflows with provable outcomes  
Secure and auditable system automation  

## Vision

FRAME is building a sovereign computing layer where AI, identity, and execution are unified under a deterministic and verifiable model. The goal is to make intelligent systems reliable enough to operate critical workflows without ambiguity.

## Status

Active development