Your agents stop suggesting. They do the work.
Tell PA·dev a goal. It plans the work, waits for your approval, dispatches a sub-agent at each task, and reports back per milestone. Memory, personas, and privacy zones are the primitives it runs on — the substrate, not the headline.
curl https://aipocketagent.com/api/v1/scaffolds \
-H "Authorization: Bearer pa_live_…" \
-d '{ "goal": "Add usage-based billing to the API" }'
# 200 OK — a plan, not an action. Nothing runs until you approve.
# {
# "run_id": "run_8fK2",
# "project": "Add usage-based billing to the API",
# "status": "awaiting_approval",
# "milestones": [
# { "m": 1, "title": "Meter the API calls", "tasks": 2 },
# { "m": 2, "title": "Stripe + invoicing", "tasks": 3 },
# { "m": 3, "title": "Backfill + verify", "tasks": 2 }
# ]
# }
# Approve it, and the dispatcher fires a sub-agent at each task.
curl https://aipocketagent.com/api/v1/runs/run_8fK2/approve \
-H "Authorization: Bearer pa_live_…"
# 200 OK
# { "run_id": "run_8fK2", "status": "running",
# "dispatched": 7, "reports": "per milestone, not per token" }A brain you own, shared by every agent you build.
Your context is yours.
Your brain lives in a Git repository you own — plain Markdown files you can read with cat, not rows locked inside someone else's vector database. PA·dev reads and writes that folder over the API, but the folder is yours: clone it, grep it, edit it by hand, host it on your own GitHub. Privacy is enforced at the row, so a public-facing agent physically can't read what you've tagged customer-private — it's checked server-side before the model ever sees the data, not asked for politely in a prompt. If you ever want to leave, there's nothing to export. You already have the folder.
Your agents should compound.
Most agents start every session from zero. You explain your business, your preferences, the way you like things done — and the next morning you explain it all again. PA·dev gives every agent the same memory, split into three tiers: the work it's doing right now, the durable facts it has learned about you and your customers, and the patterns it's picked up over time. The agent you taught last month in Claude Code is the same agent that answers in Cursor, in an MCP client, and in the cron job running at 3am, because they all read and write one brain. Teach it once and the lesson sticks, everywhere.
Your tools should plug in, not be locked out.
Whatever you're already building with, PA·dev meets it where it is. There's a plain REST API for your own code and an MCP server for the agent clients that speak it, so the same brain answers a curl from your terminal and a tool call from Claude Code. You bring the model: PA-managed Claude out of the box, or your own key for Anthropic, OpenAI, Groq, Grok (the model from xAI — not a typo for Groq, the inference layer, which we also support), or any OpenAI-compatible endpoint. The MCP server is open source under MIT, so you can read every line, run it locally, and mock the API before you ever pay for a key.
What “orchestrator” actually means.
The word gets thrown around, so here is the concrete version. You give PA·dev a goal in plain language. Instead of charging ahead, it breaks the goal into a plan — a project, its milestones, the tasks under each — and shows you that plan before it does anything.
You approve it. Then it fires a sub-agent at each task, runs them, and reports back as “milestone two of three is done,” not as a token counter ticking up. Every external action — an email, a charge, a commit — waits for your one-tap approval first.
Add usage-based billing to the API.
Here's the plan before I touch anything. Three milestones, seven tasks. Approve it and I'll fire a sub-agent at each task and report back per milestone.
Project · Add usage-based billing to the API
- M1Meter the API calls2 tasks
- M2Stripe + invoicing3 tasks
- M3Backfill + verify2 tasks
Why I built this
I run three businesses. A roofing company here in Tennessee, an agency that builds software for other contractors, and a sports SaaS for the people who run youth teams. All three run on AI assistants now — I'm in Claude Code most of the day, Cursor when I'm in someone else's repo, and a handful of cron jobs that draft and follow up while I sleep.
Every one of those assistants forgot everything I taught it the day before. So I started copying context around. The way I like proposals formatted went into a file I pasted into Cursor; my customers' details went into another I pasted into Claude. Then I was copying the same notes between repos, and then into the cron jobs, and at some point the plumbing had quietly become the product. I was spending more time feeding my agents than getting work out of them.
So I built one brain they all share — one folder of Markdown I own, one key, one endpoint. The assistant I teach in the morning is the same one running at 3am. PA·dev is that brain, opened up so your agents can read and write to it too. It's the exact thing I run my own businesses on, not a demo I spun up to sell you.
If you're building anything with agents and you're tired of teaching them the same things every session, this is the thing I wish someone had handed me a year ago.
Five primitives, one substrate.
Memory, personas, and privacy zones describe the brain. Scaffolds plan the work. Your model is the one choice you don't have to make twice.
Memory that persists
Write a fact once and your agent recalls it next session instead of asking you again. It's split into tiers — the task at hand, the durable things it knows about you and your customers, and the patterns it's learned — so recall stays sharp instead of one giant blob you re-stuff into every prompt.
POST /v1/memorySpecialists you can spawn
Give an agent a name, its own instructions, its own model, and its own slice of the brain, and you've got a specialist you can reuse. Run it as an internal teammate, hand someone a public link to it, or embed it on your site — the same spec, three surfaces.
POST /v1/personasPrivacy at the row
Tag your data by zone and the rule is enforced server-side, before the model sees anything. A public-facing reply physically can't read what you've marked customer-private — it's a check in the database, not a line in a prompt you're hoping the model respects.
POST /v1/zonesYour model, your call
Start on PA-managed Claude, or bring your own key for Anthropic, OpenAI, Groq, Grok, or any OpenAI-compatible endpoint. Six providers run through one dispatcher, so switching models is a config change, not a rewrite.
POST /v1/brainPlans the agent follows
Hand PA·dev a goal and it breaks it into a project, milestones, and tasks before doing anything — a plan you approve, edit, or reject. Once you sign off, it fires a sub-agent at each task and reports back as milestones completed, not as an opaque count of things it did.
POST /v1/scaffoldsEvery endpoint, the auth model, and the full request and response shapes.
The full APIIf you're already using LangChain memory, Letta, Mem0, Pinecone, or a memory OS like EverOS — here's the honest comparison. (see /vs)
Identity
Quote Bot — drafts roofing supplement letters and proposals in the voice of the business owner, never in a generic AI register.
Mandate
Turn inspection photos and a job file into a one-page proposal the owner can send with one edit. Stop at the draft; never send.
Voice
Plain, direct, no filler. Price as a single number, scope as three bullets. Matches the owner's saved snippets, not a template.
Knowledge zones
Reads customer-private (job files, photos) and knowledge (pricing book). Cannot read other owners' data or anything tagged internal.
Tools
memory.recall, scaffolds.create, drafts.write. No send, no charge, no commit — every external action stages for approval.
… 7 more — Failure modes, Escalation, Examples, Limits, and the rest.
A persona is just a spec.
A persona isn't a black box. It's a readable spec — the same twelve-section shape PA uses internally — that says who the agent is, what it's allowed to touch, and how it should sound. You can read it, edit it, and check it into version control like any other file.
Because it's a spec and not a running process, a whole team can share one persona instead of each person rebuilding their own. Here is a real one, trimmed to the first few sections.
Get a key. Make a call.
The quickstart wires PA·dev into your agent client and ends with a verification command, so you know it works before you build on it.