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 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.
Do not describe this as magic. The important part is not just speed. It is that the output is governed, inspectable and replayable.
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.
Performance in detail
The gauntlet shows where aiMe fits. Larger frontier models still win on broad chat, coding and encyclopedic recall. aiMe earns its place by staying compact, deployable and auditable while holding a governed floor when the world shifts.
| Signal | aiMe | Larger models |
|---|
This is a fit map, not a leaderboard. aiMe is designed to run close to the work, from private deployments and APIs to agents, edge surfaces and lightweight web experiences, while keeping the same governed runtime and proof path.
Full matrix
A new class
Most AI products stop at text. aiMe combines response, governed action, proof, replay and promoted operational learning inside one compact runtime.
Honest scoring
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.