Prentice · for anyone with a company to build

A software factory that learns from you.

Give a team of agents one goal: spec, build, review, test, write the release notes and the launch post. They work in a sandbox on your Mac, and everything they make waits on your Desk. Every keep, cut and reason you give becomes how they work next time.

Ask for the beta macOS 13+ · runs on your Claude Code or Codex login · MIT, open source soon

A simulated workshop, recorded in the real app: six agents on one goal, two weeks in. Names and numbers are made up; the screens are not.

The team

Every company is a team of jobs.

A bench is one goal and the agents working on it: one shared budget, one review lane. Start an agent from a template, or describe the job and Prentice interviews you and writes the agent for you.

PR reviewerShips todayReviews the PRs waiting on you, at their own head, with findings pinned to file:line.
Ops checkShips todayRuns your script on a schedule and reports only what changed.
Daily noteShips todayA morning brief written from the sources you point it at.
Spec writerTemplate nextTurns interview notes into a one-page spec you can argue with.
BuilderTemplate nextDrafts the change in its own git worktree. You merge; pushing stays off by default.
QA sweepTemplate nextRuns your test and smoke suites and flags what broke since yesterday.
Release notesTemplate nextDrafts the changelog from what actually merged.
Launch copyTemplate nextDrafts the post and the landing copy, in the voice you taught it.

benches/ship-quillo/
  bench.toml    # the team, one daily ceiling
  goal.md       # read first by every agent
agents/pr-review/
  agent.toml    # when it runs, model, budget
  prompt.md     # the job
  direction.md  # the rules you taught it
  brief.md      # what you asked for

A team is plain files in a folder you own. Read them, diff them, keep them in git. They work without this app.

Next: whole-company templates, a bench in one step. A SaaS launch, an open-source maintainer's desk, a content studio, an agency back office.

The human feedback loop

Agents draft. You decide. They remember.

Most agent tools stop at the output. Prentice treats your judgment as the training signal, so the team gets better at your project rather than at projects in general.

1
Run
On its own schedule or when you ask, in its own git worktree, inside a budget and a deny list.
2
Draft
It hands back findings you judge one at a time, not a wall of text.
3
You decide
Keep, cut or send back. Every judgment carries a reason.
4
Teach
Turn what you judged into a line of direction. You write it, or accept a diff you talk through. Every change can be reverted.
5
Run again
The next prompt carries the new direction and your latest twenty judgments.

A reason says whose fault it was

The agent got it wrong: False positive, hallucinated, wrong severity, duplicate, not actionable.
The input was wrong: Missing context, wrong target, stale input.
A matter of taste: Style preference, out of scope, too minor.

So a cut teaches the right lesson: a wrong input fixes the materials, not the agent.

agents/pr-review/direction.mdtalked through, accepted

- Don't restate what the linter already says.
- Money is integer cents end to end.
+ Flag a missing Idempotency-Key on any endpoint
+   that moves money, as a blocker, never a minor.
+ Never flag test-file naming or layout.
+   cut three times as too minor

From the demo workshop. Direction is always written or accepted by a person; the machine never edits it on its own.

Agentic engineering, the way we build it

Principles the code enforces.

Each one is a rule in the source, not a slogan. The small print names the idea it comes from in the wider literature on building agents.

Nothing leaves until you decide.: Publishing sits behind four gates: your decision, an allow list, approval, and a read-back.; Human checkpoints
Posted means verified.: After it posts, Prentice reads the comment back. A mismatch says unverified, never done.; Ground truth from the environment
Your agent is a folder you own.: Four plain files. No hidden prompt in someone else's account.; Own your prompts
The machine proposes; you write the rules.: Only your click changes direction, and every change is a revision you can revert.; Own your context window
Small agents, one job each.: One agent, one job. A bench groups them by goal; nothing batches runs by time.; Small, focused agents
Sandboxed, with a ceiling.: Its own worktree, a deny list, a timeout, and a budget per run and per day.; Guardrails · sandboxed execution
Policy only tightens.: Deny lists add up, allow lists narrow, the lowest ceiling wins, and the Policy screen shows the trace.; Least privilege
Costs are read back, never guessed.: Spend comes from the CLI's own report. If nothing was measured you see a dash, never $0.00.; Transparency
Every judgment keeps its reason.: Decisions are append-only and an undo is one more record. Your reasons are the eval set.; Evaluation-driven iteration
One run is the unit.: Every run stores what it was asked, what it drafted, and what shipped, so any result can be traced.; Simple, composable patterns

High-level design

One run, end to end.

Prentice is not an agent. It schedules, fences, records and asks you. The work is done by the agent CLI you already pay for.

Agent folder
prompt, direction, manifest, and the bench goal
Schedule
its own cron through a launchd tick, or Run now
Prepare
merge policy, check the day's ceiling, assemble the prompt
Sandboxed run
git worktree, deny list, timeout; Claude Code or Codex
Draft + spend
findings, events, and usage read back from the CLI
Desk
you keep, cut or send back, each with a reason
Publish
four gates, then post and read it back to verify
Revise
your judgments become direction you accept
↺ direction goes back into the agent folder, and the next run starts from there

Local-first

Yours, on your Mac.

Runs on: macOS 13 or later, Intel or Apple silicon. One app, a local Desk.
Does the work: Your Claude Code or Codex login. Prentice has no API key of its own; your subscription pays.
Dependencies: Zero. Python's standard library, on purpose.
Leaves your Mac: What your agent CLI sends, an hourly version check against npm, and a no-payload network probe. No analytics, no account, no server.
A real cost: One PR review on Sonnet: $0.11, 29 Sep 2026.

Not yet, said plainly

Network-off withholds network tools; it is not a network jail.
Agents on a bench work side by side. Handing work from one to the next comes later.
Proposed folds come from a revise you start. Suggesting them unprompted comes later.
The app is ad-hoc signed, not notarised, until the Developer ID lands.

v0.1 · private beta