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.

The forestry/off-network story is a historical design scenario, not a shipped install or peer-injection capability. The retained local source can be evaluated by an operator, but no authenticated exchange is accepted until the RAPP/1 trust requirements are met.

The source includes a local Flask application. Offline behavior, models, and dependencies are operator-evaluated; there is no supported offline or default installation claim.

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

RAPP explores a plain-Python local agent model. Azure Functions and Copilot Studio adapters are retired design history, not current promotion targets.

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.

The historical port-7071 application can discover *_agent.py locally. No cloud or anywhere-runtime parity is claimed.

You do not: no public macOS, Linux, WSL, Windows, project-local, or browser installation is currently shipped. Files retained under installer/ are contained legacy artifacts.

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.

The former three-tier model is retired:

• Local: source application plus a separate loopback-only pre-acceptance façade.
• Tier 2 — Cloud: retired; no Azure service is shipped.
• Tier 3 — Copilot Studio: retired; no connector is shipped.

There is no unchanged cross-tier or production 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.