Tiny runtime
Small enough to run close to the work: browser, mobile, private cloud, edge and constrained environments.
aiMe, pronounced "Amy"
aiMe is a compact, personalised, decision runtime that can act under uncertainty, work offline, and produce a replayable ledger of every decision it makes.
It is not an LLM, wrapper or agent framework. aiMe turns vague intent into governed action using a tiny runtime that can run in a browser, on mobile, in private cloud or inside constrained devices.
Scale
A single aiMe instance can sit beside a user, device, workflow or application and make local governed decisions in real time. That is already useful.
Because aiMe is small, it is not limited to one central assistant. You can deploy many of them: one per user, one per device, one per workflow, one per customer, one per agent, one per decision boundary.
Each aiMe can operate independently, maintain its own context, follow its own policy and produce its own ledger. When needed, aiMes can coordinate as swarms: large numbers of tiny governed intelligence units working together without becoming one opaque black box.
The difference
Most AI systems depend on large remote models, prompt chains and opaque agent behaviour. aiMe takes a different path. It is a compact runtime for resolving intent, applying policy, making decisions and recording proof.
Capabilities
Small enough to run close to the work: browser, mobile, private cloud, edge and constrained environments.
aiMe does not need an internet connection in the hot path. It can keep deciding when cloud AI cannot.
Every meaningful action can be recorded as a replayable decision event: context, policy, confidence, outcome and proof.
aiMe can sit in front of LLMs, agents and OpenAI-compatible tools as a trust, routing and governance layer.
aiMe is not just a wrapper. It can operate independently using its own runtime decisioning.
Deploy one aiMe or millions. Each instance remains small, governed and inspectable.
Execution
aiMe can resolve vague English intent into structured, executable outcomes extremely quickly. In internal tests, it has produced complete runnable application structures in milliseconds while preserving the decision trail behind the result.
A row is accepted only if the verifier can re-derive it from the environment plus the frames. Nothing is taken from the producer's self-report.
Deployment
aiMe is designed to run where decisions actually happen: inside products, tools, workflows, private environments and edge contexts.
Run governed decisions inside web surfaces without routing every action through a remote model.
Keep decisioning on the device when latency, privacy or connectivity make cloud AI a poor fit.
Operate inside constrained hardware where a full LLM stack cannot live in the hot path.
Deploy inside customer environments without turning every workflow into external inference traffic.
Sit beside existing products, APIs and operational workflows with policy and proof attached.
Work with LLMs, agents, MCP tools and OpenAI-compatible clients as a governed runtime layer.
Proof
Most AI systems leave behind a transcript. aiMe leaves behind a ledger.
Verification
The proof bundle ships a verify-only reproducibility pack: Rust verifier source, artifacts, checksums, and exact expected verdicts. A skeptic re-derives every claim from the data — nothing is taken from the producer's self-report.
| Proof | Re-derived claim | Verdict |
|---|
Deterministic, offline native verification (~690 KB). Same inputs ⇒ identical outputs on any machine. Download the pack to reproduce every verdict locally.
Compression
Carbon is aiMe's content compressor for source code. It reconstructs files byte-for-byte while producing a smaller output than zstd-19 — a large fraction of each file is regenerated rather than transmitted, so only the genuinely novel content is shipped. Every file is verified to round-trip exactly inside the run.
| Result | Measured on held-out source | vs zstd-19 |
|---|
Reproduce on your own files with the shipped tool. The method is proprietary.
Source control
aim is aiMe's git alternative. It reconstructs a working tree byte-for-byte, and over a repo's lifetime it moves far fewer bytes to a remote — meaning-preserving change is what travels, so an org-wide reformat costs essentially nothing. The wire is content-addressed and transport-agnostic. Numbers are measured pack-vs-pack through git's own packer, or re-verified byte-exact.
| Result | Measured to a remote (pack-vs-pack) | vs git |
|---|
Reproduce it yourself with the shipped tool and the open benchmark.
Early access
aiMe is currently in private beta. We are working with selected technical users, partners and organisations that need governed intelligence close to the work.