Moa.Master of Agents.
Build a portable agent with memory. Run it from the tools you already use.
A mounted agent is a reusable agent package: instructions, memory rules, and setup notes that can be loaded by Claude Code, Codex, MCP clients, or another runtime. Moa helps you design one from a rough idea, test the weak spots, and package it so other builders can run it without guessing how it works.
Build phases
06
Memory design
included
Review gates
before ship
Primary command
/moa
Moa turns a rough agent idea into a runnable agent package.
Most agents start as a long prompt and a hope. Moa makes the work explicit: what the agent does, what it remembers, which tools it needs, how it should fail, and how someone else can run it later.
Define the job
Name who the agent serves, what repeated task it handles, what good output looks like, and what can go wrong if the agent is vague or overconfident.
Write the operating instructions
Turn the idea into clear behavior: voice, process, decision rules, examples, and refusal patterns. The result is an agent that knows how to work, not just how to sound.
Choose what it remembers
Decide which facts, decisions, preferences, and project state should persist across sessions. Moa keeps memory useful and scoped instead of turning it into a junk drawer.
Check the design
Look for unclear boundaries, unsafe memory, missing setup steps, weak instructions, and tool assumptions before anyone relies on the agent.
Run realistic trials
Test the agent against requests it will actually see. Every failure becomes a concrete edit to the instructions, memory plan, or setup notes.
Package it to run
Leave behind a portable package with install instructions, memory rules, and a load check so the agent can run in another supported environment.
From idea to runnable agent.
The output is more than a prompt. It is a portable agent with operating instructions, memory behavior, setup requirements, and enough review to make the handoff sane.
A clear agent setup
Name, purpose, install surfaces, required tools, memory rules, and the instructions needed to load the agent in a supported runtime.
Instructions with structure
Separate identity, workflow, rubrics, and examples so the agent can be edited without turning into one fragile mega-prompt.
Memory it can actually use
A plan for what the agent should remember, who can see that memory, and when the agent should update it.
Review before sharing
A checklist and trial run that catch broken assumptions before the agent reaches another user or team.
Moa says no when the agent is not ready to run.
That is the point. Moa blocks vague jobs, unsafe memory, unnecessary tools, and hand-wavy instructions. A failed review item has to become a specific edit before the agent should be shared.
readiness checklist
Does the agent know exactly what job it owns?
Is every remembered field useful to future work?
Can the target runtime actually run the required tools?
Is private, team, and shared memory separated correctly?
Does the agent know when to refuse or ask for a human decision?
Run Moa from the environment where you already build.
Tokenrip hosts the portable agent package and memory rules. Your model runtime does the reasoning. The installer stays thin, so future Moa updates load without reinstalling.
Install the bootloader once, then call any agent with /tokenrip-bootloader <agent-id> (the slug from the agent’s URL).
Step 1 — one-time install
mkdir -p .claude/commands && curl -fsSL https://api.tokenrip.com/commands/tokenrip-bootloader.md -o .claude/commands/tokenrip-bootloader.md
Installs the tokenrip-bootloader Claude Code slash command. Loads + runs Tokenrip agents end-to-end via the rip CLI. Distinct from the optional tokenrip-cli skill (auto-loaded context for publishing your own work) — install one, both, or neither independently.
Already installed? Skip to step 2.
Step 2 — invoke this agent
/tokenrip-bootloader moa