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.
every start, every world → one target
provenance, overlap, and physics forgeries fail
878 / 878 fraud caught; novel patterns escalated
offline · no LLM · no network
| Proof | Re-derived claim | Verdict |
|---|---|---|
| Frame log | aime-proof-verify frames2000 frames · 0 violations · 1000/1000 grounded arrivals |
PASS |
| Atlas | aime-proof-verify atlas200 worlds × 1000 starts → one endpoint [[0,0,0,0]] |
PASS |
| Tamper | aime-proof-verify tamperAll forged logs rejected (provenance · overlap · physics) |
PASS |
| Fraud | aime-proof-verify fraud0 silent fraud misses · 123/123 novel frauds escalated |
PASS |
| SVG dot | aime-proof-verify svg-dot5 / 5 cases · dot detected · hard negatives ignored |
PASS |
| SVG traces | aime-proof-verify svg-traces10 / 10 variations detected · faint scores below bold |
PASS |
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, shipped in the aim CLI (aim carbon). 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. Byte-exactness is asserted on every file inside the run.
~28% smaller on held-out source, losslessly
held-out files reconstruct identically (in-run)
on real, held-out Rust source
only the novel content is transmitted
| Result | Measured on held-out source | vs zstd-19 |
|---|---|---|
| Byte-exact codec | aim carbon pack/unpackreconstructs the original source files losslessly · 1.480 b/B vs zstd-19 2.053 · 44/44 held-out verified |
1.39× |
| Size win (held-out) | aim carbon bench~28% smaller than zstd-19 on held-out source, under 1.5 bits/byte |
-28% |
| Lossless round-trip | aim carbon unpackevery held-out file decompresses byte-for-byte identical to the original |
44/44 |
| Safe fallback | aim carbon packinputs it cannot model fall back to a standard baseline · never larger · always byte-exact |
PASS |
Reproduce on your own files with the shipped tool: aim carbon pack <input> -o out.carbon, then aim carbon unpack out.carbon -o restored (identical to the input). aim carbon bench <dir> --ext .rs prints carbon vs zstd-19 bits/byte and re-asserts byte-exactness. The method is proprietary.
Source control
aim is aiMe's source-control core — the git alternative. It reconstructs every file byte-for-byte (git parity) and is already smaller than git's pack at rest. And because aim tracks meaning rather than bytes, an org-wide reformat costs essentially nothing — far fewer bytes cross to a remote over a repo's life. The wire is content-addressed and transport-agnostic (not bound to HTTP).
aim verify = byte_exact; every file reconstructs identically
EXACT mode 29,703 B vs git pack 156,897 B, losslessly
meaning-preserving: git re-ships 1.21 MB; aim ~1.7 KB
meaning-preserving representation, over 40 commits
| Result | Measured to a remote (pack-vs-pack) | vs git |
|---|---|---|
| Byte-exact fidelity | aim verifycommit -> checkout reconstructs every file identically; whole-tree semantic root_hash |
PASS |
| Byte-exact size at rest | aime-aim-benchEXACT mode is byte-lossless AND smaller than git's pack: 29,703 B vs 156,897 B |
~5× |
| Reformat-sweep cost (meaning-preserving) | aime-aim-bench --history 4010 org-wide reformats: git re-ships 1,213,974 B; aim ships 1,716 B (canonical frame unchanged) |
≈ free |
| Cumulative wire, lifetime (meaning-preserving) | aime-aim-bench --history 40bytes that cross to a remote: git 1,280,277 B vs aim 71,247 B — pack-vs-pack, git's own packer |
18× |
Reproduce it yourself: aim init && aim commit -m snapshot && aim verify prints byte_exact = true on any tree. cargo run -p aime-aim-bench --release -- --history 40 --reformat-every 4 measures lifetime wire/storage to a remote (pack-vs-pack, git's own packer). Byte-exact (EXACT) mode is git parity and ~5x smaller than git's pack at rest; the 18x figure is the meaning-preserving representation (formatting normalised).
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.