FAQ

Portability and determinism. When you build a GPT or a Claude Project, it runs inside that vendor's chat. You can't share it with someone on a different stack. RAPP agents are single Python files — you drop one in a Teams chat, your teammate's brainstem loads it, and it behaves identically. Code, not vibes.

The other ecosystems are non-deterministic skills and plug-ins. They'll bite teams in the butt for the next year — people will learn them, then have to consolidate them, and nothing will be translatable. RAPP sidesteps that: the agent is a file. Files don't care what ecosystem you live in.

You're a forestry person monitoring IoT devices in the woods. The device has RAPP installed. It can do its job completely off-network. When someone with a different RAPP agent walks up, they can inject their agent into yours, on-device, and now your brainstem has new capabilities — no cloud round-trip, no vendor sync, no account.

You can't do that with a GPT, a skill, or a Copilot Studio agent. Those are all cloud-tethered, account-tethered, and vendor-specific. RAPP agents are physics: local files.

Yes. The brainstem is a tiny local Flask server. Point it at a local LLM (LLaMA, Ollama, whatever you have) and the whole thing runs on-device. No internet required after install.

The default install uses GitHub Copilot as the LLM because it's one-click to authenticate (gh auth login) and costs nothing beyond a GitHub account. But that's a dial you can turn. Provider is the cloud operator's choice, not the learner's.

Copilot Studio is great for structured, bounded scenarios inside M365. It can only do what the product surface exposes.

RAPP can do anything Python can do. Python has the libraries; Copilot drives RAPP to generate agents that use them. And because every agent is a single file, there's no ecosystem lock-in — the same agent runs on a laptop, on Azure Functions, and inside a Copilot Studio solution. It extends Copilot Studio rather than replacing it.

Skills and plug-ins are non-deterministic: they're markdown files the LLM has to interpret, so the same skill can behave differently on different machines, different days, different models. Across years that compounds into a consolidation problem nobody's looking forward to.

RAPP agents are deterministic: they're Python code with a strict contract (one class, one perform(), one metadata dict). Same input, same output, every time, every tier.

It means: one file. Copy it. AirDrop it. Paste its contents in a Teams chat. Email it. Attach it to a JIRA ticket. The file travels; the behavior travels with it unchanged.

There's no framework around the file. No YAML. No build step. No registry. The brainstem sees *_agent.py on disk and picks it up automatically — local, cloud, anywhere.

One line on macOS / Linux / WSL:

curl -fsSL https://kody-w.github.io/RAPP/installer/install.sh | bash

Or project-local (doesn't touch your home dir; installs into ./.brainstem/, gitignored):

curl -fsSL https://kody-w.github.io/RAPP/installer/install.sh | bash -s -- --here

Windows PowerShell:

irm https://raw.githubusercontent.com/kody-w/RAPP/main/installer/install.ps1 | iex

First chat walks you through GitHub sign-in. After that you're talking to your brainstem in a browser tab.

A swarm is a folder of agents that are good at working together on a class of problem. You build it in workspace_agents/my_swarm/, iterate, and when it's ready you run the swarm factory to converge all the files into one portable *_agent.py file.

That singleton is the swarm, packaged for distribution. Someone else drops it in their agents/ folder and they have the whole swarm running in seconds.

Nothing. Configuration is never a source edit. If an agent needs a name, a path, a token, or a preference, it declares it as a required parameter. The LLM asks you for it in chat, and the answer goes into your memory file so it stays there on future turns.

This means agents travel read-only between people. You don't have to open someone else's agent to use it.

Three tiers, one model:

• Tier 1 — Local: brainstem.py on your laptop. GitHub Copilot drives the LLM. Single user.
• Tier 2 — Cloud: the same brainstem deployed to Azure Functions. One deployment serves many users; each user gets their own memory namespace via the user_guid they send in the request.
• Tier 3 — Copilot Studio: a Power Automate flow passes the signed-in user's AAD identity into Tier 2 as user_guid. One MCS connector serves N users. Zero per-user setup.

An agent written on your laptop runs unchanged in all three tiers. That's the whole platform promise.

The agents are deterministic. If the LLM picks the wrong agent, the logs show you exactly what got called with what arguments. No guessing which skill fired.

If the network is down, local agents still work — file I/O, Python libraries, on-device sensors all keep functioning. Only the LLM conversation pauses. When you come back online, it continues. Memory files persist.

Give it a goal; it spins up a swarm that does the work and learns from it. Share the file. Everyone runs it. Offline, online, laptop, Azure, or Teams.

See the one-slide version.