The operating system for autonomous software engineering. LOOPRITE gives AI coding agents durable, file-based memory and a deterministic execution protocol — vendor-neutral, resumable, and gated by explicit human confirmation. Now running in your pocket.
AI coding agents forget everything between sessions, and every vendor locks that memory into its own proprietary state. LOOPRITE fixes both: it puts the agent's memory, plans, events, and safety rules into plain files inside your repository — readable and writable by any agent. Claude can plan, Codex can execute, Gemini can verify and respond to review comments, and whatever ships next can resume all of it from files. No backend. No hosted service. No lock-in.
The .l00prite/ folder holds the blueprint, run ledger, durable decisions,
constraints, known failures, and todos — the project's whole working memory as
Markdown and JSON, versioned with your code.
Six canonical prompts — resume, heartbeat, event, review, handoff, execute — define exactly how any agent picks up the next unit of work, verifies it, and persists what happened before stopping.
PR review comments and failed CI runs become first-class JSON events with a real
lifecycle — pending → processing → completed — handled one at a time,
always treated as untrusted input.
heartbeat.json carries iteration budgets, continue/pause/stop signals,
and review gates — so a loop knows when to keep going and when a human has to look
first.
A lock/lease convention (lock.json) keeps agents working close together
in time from silently corrupting shared memory — check, acquire, respect, reclaim
stale, release.
ledger.md records what actually happened, run by run, with the
verification evidence — the commands that ran and what they proved. Progress you can
audit, not vibes.
Autonomy without a gate is a liability. LOOPRITE splits agent work into two modes — and the autonomous one can only be entered through an explicit, in-session human confirmation. Every run. No carry-over grants, and no persisted flag can ever stand in for you.
Clarifies requirements, generates a blueprint, scaffolds the repo and its
.l00prite/ memory — then stops. Planning never executes the
project it scaffolds, and always ships Execution Mode disarmed.
Reads the blueprint and iterates autonomously — plan a unit, execute it, verify it with recorded evidence, persist memory, repeat — until Definition of Done or a run boundary stops it.
iteration_limit_reached to destructive_operation_required, every exit is resumable
The beta APK ships the unmodified LOOPRITE gateway as a native arm64 binary and
runs it entirely on-device — guided first-run setup, a chat-first interface with
cross-provider bridging, and autonomous runs in a WebView on 127.0.0.1.
Bring your own keys — Claude, GPT, Gemini, Grok, Kimi and more. Your provider
keys are sealed by an Android-Keystore-wrapped master key and never leave the
device. There is no LOOPRITE cloud: your phone is the server.
cli-os/scripts/build-apk.sh.EXECUTE. Merges,
deploys, and anything destructive always wait for your explicit approval — pushes
and pull-request creation do too, unless you opt a project into the Auto-PR toggle,
which pre-approves just those two and shows up clearly in the pre-flight before you
type EXECUTE.This beta is signed with LOOPRITE's own release certificate (not Play Store, not a debug key) and delivered from looprite.click, so Android has no Play record to check it against and flags what it can't recognize. That's the expected consequence of sideloading — but don't override any warning on faith: verify the file's SHA-256 against the checksum below first, then proceed. Here's the sequence you'll see:
Don't take our word for it: check the file's SHA-256 against the checksum below, and read the source to see exactly what you're running. (A self-built APK won't be byte-identical to this download — the build stamps a timestamp version code and signs with your own local key — so verify the published file by its SHA-256, not by diffing your own build.) Two hygiene tips: revoke Install unknown apps for your browser after installing, and if you installed 0.10.0-beta or earlier, uninstall it first — this is the first production-signed build, so Android will refuse an in-place update from the old debug certificate. Later 0.10.x builds signed with this same LOOPRITE certificate will update in place. Fair warning before you uninstall: it deletes everything the app stored on your device — provider keys, tokens, and imported repos — so you'll run setup again from scratch. Nothing is recoverable from a cloud, because nothing ever left your phone.
LOOPRITE is under active development and this Android build is a beta: it is release-signed, distributed from looprite.click outside the Play Store, and rough edges are expected. Point it at repos you can afford to experiment on, keep Execution Mode's approval prompts on, and expect breaking changes between releases. Found something weird? Open an issue — beta reports shape the release.
LOOPRITE is built off the l00prite source code — the vendor-neutral protocol, the gateway, the run engine, and this very APK pipeline are all MIT-licensed and public. Read the prompts your agents will follow. Audit the run boundaries. Build your own APK from the same source. That's the point.
Protocol spec, canonical loop prompts, vendor adapters, the Go gateway, the run engine, validators, and the hermetic Android build — one repo, MIT license.