Posse

AI job orchestrator

Round up a posse of agents.

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.

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.

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

Claude OpenAI Codex Grok Copilot Local 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.

Join the iPhone beta