RAPP

· New to RAPP? Start here: get your Brainstem →

AI that runs anywhere. One line turns any computer you own into part of your AI.

Every Brainstem is an atom: a small AI that runs on any computer (a Mac, a Windows PC, a Linux box, a Mac mini in a closet), with the AI you already use, and stays on. RAPP makes all of your Brainstems work in unison, so several computers act as one AI instead of separate bots.

A Brainstem is also a social butterfly: it connects the AIs already on your computer (Claude, ChatGPT, GitHub Copilot) so they share one memory and one set of abilities, instead of each starting from zero.

Start: one line

The one line that installs a Brainstem is on the installer's Start here page, for macOS, Linux and Windows. Sign in with GitHub once and your Brainstem opens at http://localhost:7071. Run the same line on another computer and it adds another atom to your AI.

What people do with it

You want	What you do	Status
An AI that is always on, on a computer you already own	Run the one line on an old laptop or a Mac mini and leave it running	Works today
An AI that remembers you	Tell it about yourself and your projects; it keeps that memory on your machine	Works today
New abilities without coding	Add an agent from the registry: each one is a single file that does one job	Works today
Your AI inside the AI apps you use	Connect your Brainstem to Claude, GitHub Copilot or ChatGPT with brainstem-mcp; they share its memory and agents	Works today
Your Brainstem in the cloud, always reachable	Deploy it to Azure as a Tier 2 Brainstem with CommunityRAPP	Works today

What RAPP does that other AI tools don't

RAPP + Brainstem	Claude Code, ChatGPT, Copilot	Why it matters
Runs on any computer you own and stays on	A session in a terminal, or an app on someone else's cloud	Your AI keeps working while you sleep, on the old laptop in the closet
Abilities are files you own and run the same on every Brainstem	Custom agents live inside one product	You keep what you build, and you can share or trade it
Any AI model, switched with one setting	Mostly one vendor's models	Use the best or the cheapest model for each job, free ones included
A core that doesn't change, proven identical everywhere	Updates change behavior under you	What worked last month still works the same way
Claude, ChatGPT and Copilot can connect to your Brainstem	Each AI is separate	Every AI you use shares one memory and one set of abilities
Memory stays on your machine	Memory lives on their servers	Your life stays yours
A shared record your computers can check	No shared record between tools	Your computers agree on what happened, and you can verify it

They do some things better: Claude Code is the stronger coding agent, ChatGPT is the more polished app, and MCP has the biggest ecosystem of tools. RAPP gives them a home: they connect to your Brainstem, and your Brainstem runs where they can't.

Runs on RAPP: join the network

Outsiders are welcome, people and AIs alike. Anything that passes the same checks we hold ourselves to gets the Runs on RAPP mark and works with every Brainstem.

You built	Prove it with (from rapp-1)	Status
Agents or a repo of them	python3 rapp_check.py <your repo> reports COMPLIANT or CLEAN	Open now
RAPP in another language	python3 conformance.py: every test vector passes	Open now

To get listed, open an issue on rapp-1 with your check output and a link to your work. Certified agents go in the registry, and a certified Brainstem joins your AI as another atom.

Everything beyond the core Brainstem is an add-on from the registry. Remove an add-on and your Brainstem is exactly the original again.

Your first agent

An agent is a Python file named something_agent.py in your Brainstem's agents folder:

from agents.basic_agent import BasicAgent

class HelloAgent(BasicAgent):
    def __init__(self):
        self.name = "Hello"
        self.metadata = {"name": self.name, "description": "Says hello to someone by name.",
                         "parameters": {"type": "object", "properties": {"name": {"type": "string"}}, "required": ["name"]}}
        super().__init__(name=self.name, metadata=self.metadata)

    def perform(self, name="", **kwargs):
        return f"Hello, {name}!"

Save it, then ask your Brainstem "say hello to Ada". Every Brainstem runs the same file the same way.

Where things live

Repo	What it is
RAPP (this repo)	Start here: the docs, examples and tools
rapp-installer	The Brainstem itself and its one-line installer
rapp-1	The technical spec of the format (rapp/1) and its conformance tests
RAR	The registry of shared agents
rappterbook	A social network where AI agents post and talk

---

For AI runtimes and maintainers

Everything below is the project's status, authority and history, unchanged.

Repository authority: this is the canonical home of the public RAPP foundation, reference implementation, organism model, and philosophy. kody-w/rapp-1 is the canonical wire protocol authority; it does not replace this repository.

AI runtime entrypoint: RAPP is designed primarily for AI runtimes. Humans remain the sovereign owners, safety authorities, and beneficiaries. Start with llms.txt and the machine-readable rapp-ai.json, then verify the status and authority below before accepting any artifact. The AI capacity market described there is a proposal, not a shipped payment service.

The current migration map is RAPP1_ADAPTATION_INVENTORY.json; exact restored-source provenance is in HISTORICAL_SOURCE_LEDGER.json.

This repository is an experimental source checkout, not a currently shipped installer or hosted product. The historical port-7071 application remains only as immutable, directly invoked test evidence; its target-owned launchers return HTTP 410 semantics without starting a process. The RAPP/1 façade is a local, pre-acceptance boundary at 127.0.0.1:7073 and defaults to inference-refused until a safe adapter is explicitly injected. This repository ships no installer itself: no public one-line install, browser brainstem, Tier 2 service, downloadable egg catalog, or Shortcut is offered from it. For installation, start from the installer repo's Start here anchor.

Historical strategy: The Brainstem Mandate preserves an earlier product direction. It is not current onboarding.

Protocol status: NOT YET FULLY RAPP/1 CONFORMANT. This target structurally pins RAPP/1 rev-5, but the pin is not an authenticated §13 registry. For canonicalization, identity, frame, wire, egg, registry, trust, and evolution rules, those two files supersede older local documentation. Owner-signed registry, anchor, re-anchor, and invite work remains. The former external mirror contract is retired and has no active mirrors. The authority commit is d2cd5abed48d3f52b86bbb975ac3558286d1db41; kernel evidence is fixed by kernel.json at kody-w/rapp-installer@brainstem-v0.6.9. rapp-god and moving branches are divergent, non-authoritative history.

First-time visitor? Read the status and authority pin. Other hubs, trees, and vault paths are historical context, not current operational navigation.

Brainstem app (newest channel, not part of RAPP/1)

The Brainstem app is the one surface you talk to, with your Hives and references beside it: a minimal desktop app built from brainstem-app/ on a pinned Code - OSS fork. It is a frontier canary, not part of RAPP/1, and it joins RAPP/1 only when the owner graduates it. This repository ships no installer itself; start from the installer repo's Start here anchor. Build the app from source with brainstem-app/scripts/build.sh (build.ps1 on Windows).

What an "agent" is here

from agents.basic_agent import BasicAgent

class WeatherAgent(BasicAgent):
    def __init__(self):
        self.name = 'Weather'
        self.metadata = {
            "name": self.name,
            "description": "Get the weather for a city.",
            "parameters": {
                "type": "object",
                "properties": {
                    "city": {"type": "string", "description": "City name."}
                },
                "required": ["city"]
            }
        }
        super().__init__(name=self.name, metadata=self.metadata)

    def perform(self, **kwargs):
        return f"It's sunny in {kwargs['city']}."

In the immutable historical port-7071 source, that file would be discovered on a later request. This example describes retained application internals only; it is not an installation, launch instruction, or RAPP/1 wire contract.

Why it might be interesting

• Immutable local evidence. The repository preserves the port-7071 Flask application and its single-file agent model for inspection. Direct execution is confined to isolated canonical tests; it is not a public launch path.
• Legacy cartridges are retired. Historical brainstem egg / brainstem hatch paths and brainstem-egg/2.x artifacts are migration evidence, not operational inputs or current output. The only current egg authority is RAPP/1 §9; this target has no authenticated egg release.
• Browser and tether demonstrations are retired. Their source and dated narratives remain historical evidence. They are not shipped RAPP/1 surfaces.
• Single-file source contract. The contained application model uses one file, one class, one metadata, and one perform(); this is not a distribution or protocol promise.
• Historical Copilot adapter. Contained source includes a GitHub/Copilot token exchange. It is not advertised here as an operational hosted backend.
• No shipped tiers. Tier 1/2/3, Azure, Cloudflare, Copilot Studio, project-local installers, Cloud UI, and install-assist narratives are retired or pre-acceptance artifacts. They are not built, shipped, or operational.
• About 1,100 lines of Flask (rapp_brainstem/brainstem.py). The whole engine is one file you can read in an afternoon.

Historical external references

The platform is three sibling repos plus a Pokédex:

Repo	Holds	Role
kody-w/RAPP (this repo)	The engine source and historical organism model	No authenticated egg/hatch release
kody-w/RAR	External agent repository	Non-authoritative and unverified here; no drop-in claim
kody-w/RAPP_Store	Historical external catalog	Non-authoritative and unverified here; no supported egg download is advertised
kody-w/RAPP_Sense_Store	Historical external sense-overlay reference	Not a supported install source
rapp-zoo in the external Rappter distro	Historical Pokédex experiment	Not authoritative or shipped from this target

This table is provenance only. External repositories and catalogs do not form a current federation or acceptance source.

What it is not

• Not a hosted service or shipped local runtime. Contained source may be exercised by developers at their own risk.
• Not a framework. Single Python files; no DSL, no decorators, no class hierarchy beyond BasicAgent.
• Not a benchmark or eval harness. It's an agent runtime, not a research tool.

Distribution status

This repository's own former installation instructions (shell, PowerShell, project-local, version-pin, and LLM-assisted) are retired. Files retained under installer/ are contained historical artifacts unless a future authenticated release explicitly re-enables them. Do not pipe repository content into a shell. The grail Brainstem installs from its own repository, kody-w/rapp-installer; start from the installer repo's Start here anchor.

Repo layout

Path	What
rapp_brainstem/	The engine — Flask server, agent loader, auth chain
brainstem-app/	The Brainstem app (newest channel, not part of RAPP/1): a minimal desktop app on a pinned Code - OSS fork, built as an overlay
rapp_brainstem/agents/	Live agents: only the top-level *_agent.py files load (context_memory_agent.py, hacker_news_agent.py, manage_memory_agent.py, plus the basic_agent.py base class). Every subfolder, such as experimental/, is organization and is parked; move a file to the top to load it
rapp_swarm/	Retired Tier 2 tombstone and historical evidence
worker/	Retired Cloudflare auth/proxy source
kody-w/rapp_store (external)	Historical, non-authoritative catalog reference; no current download contract
installer/	Contained legacy distribution artifacts; not a live install surface
CONSTITUTION.md	Articles governing the repo. Peer of README.md at root
PHILOSOPHY.md	Why RAPP exists and how the foundation, protocol, and downstream LLC products remain separate
RIGHTS-NOTICE.md	Neutral repository-scope and ownership-allocation boundary
pages/	The full audience-facing site, sectioned: pages/about/ (leadership, partners, process, security), pages/product/ (faq, faq-slide, one-pager, use-cases), pages/release/ (release-notes, roadmap), pages/docs/ (markdown specs + viewer), pages/vault/ (Obsidian vault + viewer). Shared chrome under pages/_site/ (CSS, JS, header/footer partials, site manifest).
index.html	Historical root landing source; not current onboarding
pitch-playbook.html	Historical pre-acceptance marketing
tests/	Offline structural, static, and retirement gates

Tests

python3 -m pip install -r requirements-rapp1-core.txt -r rapp_brainstem/requirements.txt pytest
python3 tests/run_rapp1_conformance.py

This is the authoritative offline RAPP/1 structural/pre-acceptance runner. It includes the current self-contained node tests/run-tests.mjs checks, strict core and façade tests, containment/migrations, vault/docs/HTML, immutable pin, retirement, and syntax gates. A pass does not establish authenticated acceptance; RAPP1_STATUS.md lists the separate owner-action blockers.

Retired browser experiment

rapp_brainstem/web/index.html preserves an earlier client-side experiment. It is not built, shipped, supported, or claimed to be at parity with the local application or RAPP/1 façade.

The pitch (non-technical companion)

pitch-playbook.html is retained as historical pre-acceptance marketing. It does not describe a currently shipped product or establish a conformance claim.

Constitution & spec

• RAPP1_AUTHORITY.json — machine-readable structural pin to the exact RAPP/1 rev-5 source bytes.
• RAPP1_STATUS.md — conformance limits and unresolved owner actions.
• CONSTITUTION.md — Article LV adopts the pin and preserves incompatible earlier articles as dated history.
• pages/docs/SPEC.md and specs/SPEC.md — historical local contracts; neither is the current RAPP/1 authority.

Current protocol: RAPP/1 §7 defines the exact eleven-key frame and §8 defines the exact /chat shapes. Earlier rapp-frame/*, expanded response aliases, and additive/read-forever teachings are historical migration inputs, not current conformance rules. See Article LV and the status.

The vault

pages/vault/ preserves the project's long-form decision history. Site-rendering source and metadata remain in the tree, but this README does not claim a current hosted viewer, search, graph, or export product.

Start with pages/vault/Foundations/The Platform in 90 Seconds.md or pick a reading path by audience (engineer, architect, partner, exec, contributor). The vault is mandated by Constitution Article XXIII — when you make a decision worth remembering, write it as a vault note rather than burying it in a commit message.

Versioning & rollback

Historical releases used brainstem-v<X.Y.Z> tags. This repository advertises no installer or rollback command of its own; start from the installer repo's Start here anchor. RAPP/1 authority is pinned by exact commit and SHA-256 in RAPP1_AUTHORITY.json, not by a moving branch or latest tag.

History

The previous engine code that lived in this repo (the Rapp intelligence engine for Rappterbook) is preserved on the archive/engine branch — the "genetic twin" referenced in SPEC §16.

License

Open-source direction; current license transition pending. RAPP is the public foundation. The currently published PolyForm/CC license files remain operative until an authorized rights and contributor review completes the open-source migration for future releases. Every already-published version keeps its existing license grant permanently. Repository administration does not establish the full legal ownership allocation; see RIGHTS-NOTICE.md.

Layer	License
Code (kernel, hatchling, organs, senses, boot wrapper, tests)	PolyForm Small Business 1.0.0 — the license text controls; this README adds no exceptions or permissions
Documentation (Constitution, vault, docs, READMEs)	CC BY-NC 4.0 — read, quote, and build on with attribution; no commercial repackaging
Names and other identifiers	Reserved — the licenses above grant no rights in them; see TRADEMARK.md
Rights status inquiries	COMMERCIAL.md describes a non-binding inquiry path; it is not a license offer

License stability. Constitution Article XXXV is a public commitment that future licenses can only relax these terms, never tighten them. The bytes you clone today are licensed at this level forever — past versions cannot be retroactively re-closed. See CONSTITUTION.md Article XXXV.

Variants (per Constitution Article XXXIV) inherit this licensing stance at fork time. A variant fork is free to choose terms no stricter than upstream's at that moment; the parent_rappid chain in the variant's rappid.json records the lineage relationship so consumers can walk back to the bytes' original license.

---

Disclaimer — Experimental Frontier Software

RAPP is exploratory, frontier-stage research. The software is provided "AS IS" without warranty of any kind, express or implied, including but not limited to the warranties of merchantability, fitness for a particular purpose, and noninfringement. In no event shall the authors or copyright holders be liable for any claim, damages, or other liability, whether in an action of contract, tort, or otherwise, arising from, out of, or in connection with the software or the use or other dealings in the software.

By cloning or otherwise interacting with this source checkout, you acknowledge that historical planting/hatching language does not identify a supported distribution path:

• This is not a finished product. APIs change, schemas evolve, behaviors get rewritten. Treat any source-run or copied artifact as research, not production.
• No warranty as to data integrity, availability, privacy, or correctness. Repositories and local state remain subject to their operators and service providers. Historical eggs have no current acceptance guarantee. Keep independent backups.
• AI output is generated by language models. If an operator runs or modifies the source to call an LLM, outputs can be wrong, hallucinated, biased, or harmful. Do not rely on them for professional advice.
• You are the operator. Any repository or process you create from this source is your account, responsibility, and liability. Review what you publish.
• GitHub permission is not RAPP trust. Repository access may protect source operations, but authenticated RAPP acceptance requires the §13 registry, signatures, succession, revocation, and an out-of-band owner anchor.
• Cross-organism collaboration is voluntary and PR-mediated. Nothing crosses neighborhood boundaries without an explicit operator action (a merged PR, a committed file). The platform doesn't auto-publish, auto-share, or auto-federate. If a peer organism receives data from yours, it's because you (or a collaborator with the right repo permissions) chose to send it.
• Third parties may be in the loop. Historical experiments reference GitHub, PeerJS, Cloudflare, Copilot, and CDNs. If you elect to run that archived code, review each dependency and its terms first; no live service is promised here.
• Legal compliance is yours. If your own use or modification processes personal data or intersects with regulated work, obtain appropriate advice; RAPP is not legal cover.
• The licenses above govern. Where this disclaimer overlaps with the license texts, the licenses control. This disclaimer is plain-English orientation, not a contract.

Forking, modifying, and contributing. You're encouraged to fork, learn, and propose improvements via PR. Constitution Article XXXIV describes how variant lineage works. The platform's growth is exactly this kind of operator-curated mutation; contributions that move the species forward are welcome under the license terms.

Reporting concerns. If you find a security issue, please open a GitHub issue tagged [security] describing the problem. Maintainers triage on a best-effort basis. There is no SLA, support contract, or on-call commitment.

The frontier is the point. This codebase preserves experiments in portable, public, operator-sovereign AI artifacts. Portability and operation remain research goals unless the status and authority explicitly say otherwise.