Posse queues your work, plans the jobs, and runs a crew of AI
agents across all your repos at once — work branches, merge contention,
secrets, and token spend handled automatically.
Direct APK — allow "install from unknown sources" on your device.
posse — trail boss
What's in the outfit
Built for many hands on many repos — without the pileups.
Everything an unattended crew of agents needs to do real work on real
codebases, and nothing that lets them hurt you.
Orchestration
Safe multi-agent orchestration
A lease-based scheduler keeps the herd moving: work items are
decomposed into jobs, ordered by their dependencies, and routed to
the right rider — with expired leases recovered and deadlocks
cancelled automatically. Scale the crew up without babysitting the
queue.
Security
100% secret-safe
Scoped tools won't touch credentials, so secrets never enter a
prompt at all — with an independent secret scan as a second fence.
Models can't leak what they never saw.
Context
Atlas code map
Every symbol indexed, every relationship charted, a semantic layer
over it all. Agents traverse the graph instead of reading file after
file — the whole codebase understood through a fraction of the
context.
Efficiency
Sharper reasoning, fewer tokens
Because Atlas scopes the context, agents reason over what's relevant
instead of wading through the whole repo — better answers and a
smaller bill from the same model.
Extensibility
Your skills, your tools
Teach the posse your conventions: package custom skills and tools
once and every agent on every repo rides with them.
Scale
Many agents, many repos
Point the whole crew at one codebase — even the same files —
without anyone stepping on anyone's toes. Every job gets its own git
work branch, and file locks with job ordering decide who rides first
when paths overlap. Git keeps the work isolated, locks keep it
ordered — merges land with zero contention.
Accounting
Token budgets & auditing
Set your own spend budgets and context caps — enforced like every
other rule, in the tools. And every prompt, output, and cost is
recorded per job: know what each agent spent, on which model, doing
what, down to the token.
Integrity
Hashed content map
Handoffs never dump context into an agent's lap. Prior research,
plans, and work products live on the backend, filed by content hash;
each agent is handed a curated map of only what it needs — cutting
through the noise and keeping it focused on its task. Anything
deeper sits a semantic hop away, expanded on demand.
Memory
Durable memories
What an agent learns is pinned to the exact functions and files it
describes, and resurfaces precisely where it applies. When the code
underneath changes, the memory's confidence fades — it stops being
offered instead of lying to the next agent.
Models
Any model, local or frontier
Route jobs across Claude, OpenAI, Codex, Grok, and Copilot — or keep
work on models running on your own hardware. Pick the right horse for
each job; swap providers without touching your workflow.
Atlas
A star map of your codebase.
Atlas tokenizes and indexes every symbol in your codebase, then
charts the relational map between them all — who calls what, what
depends on what — with a semantic layer over the top, so the whole
graph is searchable by meaning.
An agent riding Atlas doesn't hunt through files. It traverses the
map — symbol, to caller, to dependency — and understands the codebase
through a fraction of the context. That's not just cheaper. The
grep-and-read pattern floods a context window with code that doesn't
matter, and that rot is exactly what drags agents off task. Atlas
never lets it in the door.
Every symbol, indexedFunctions, classes, types, constants — tokenized into the database and charted once, no matter how many branches or agents touch them.
The relational mapAgents hop edge to edge — callers, callees, dependencies — instead of reading file after file to reconstruct the picture.
The semantic layerAsk the graph for "the auth flow" or "the retry logic." Local ONNX embeddings — nothing leaves the ranch.
Grep + file reads
Riding the map
Context loaded for the same job.
Deterministic guardrails
Prompts are suggestions. Tools are law.
Posse doesn't secure agents by writing sterner instructions. The rules
are compiled into the tools themselves — so safety never depends on a
model deciding to behave.
No going off-script
Agents never touch their stock tools. Posse swaps in its own tool
set, where every call is permission-checked deterministically — and
every job carries a hard scope, the files it's allowed to touch,
enforced at the tool boundary. An agent that ignores its
instructions still can't act outside its grant. Work is also carried
out on independent work branches that refuse to merge out-of-scope
content, providing a second layer of protection.
Your secrets never leave camp
The scoped tools flatly refuse to touch secrets — API keys, tokens,
and connection strings never enter a prompt in the first place. Behind
that boundary stands an independent secret scan, a second fence that
catches anything secret-shaped before it can slip out. And every
assembled prompt is logged, so you can verify exactly what the models
were shown.
You hold the reins
Design your own approval pipeline — wave the routine work through,
gate the risky paths, pause for a human wherever you choose. And no
decision is final: send a change back with notes and the agent fixes
its own work, or roll it back clean and ride on.
Bossy
The trail boss watches the whole fleet.
Bossy rides above every posse on your machine — each repo's agents,
queues, and live jobs at a glance, with the tab rolled up in real time:
tokens, hours, dollars.
fleet
✦
Fleet overview screenshot coming
live jobs
✦
Jobs on the trail screenshot coming
the tab
✦
Tokens & spend screenshot coming
Rides with
ClaudeOpenAICodexGrokCopilotLocal models — your GPU
Frontier when you want the best, local when it shouldn't leave the building.
Saddle up
Run the posse from your pocket.
Queue work, watch the trail, and approve review gates from the iPhone
or Android app — your agents keep riding while you're away from the desk.