A shared memory layer for agents that actually did the work
Most agent tooling stops the moment a task finishes. The run ends, the trace scrolls off the terminal, and whatever the agent learned about the job evaporates. Forsy-AI/agent-apprenticeship makes a different bet: the completed work itself is the asset. Every finished task becomes a reusable "experience compilation" that can be inspected, exported, and installed into a later run so the next agent starts with something the last one figured out.
The framing borrows from human apprenticeship on purpose. An apprentice agent takes on a real task, a mentor (another model, a human expert, or you in the loop) evaluates the output, and the workflow loop turns that execution into learning signals. The README describes this as a compounding exchange: economically valuable task execution generates training signals, those signals improve future work, and future work produces new experience for the ecosystem. Whether that loop actually compounds in practice is the authors' claim, not a measured result, but the mechanics are concrete enough to try.
What you can actually run
Installation is a single npx command:
npx agent-apprenticeship init
From there the CLI (apprentice) auto-detects installed agent CLIs and lets you pick one. The supported list is unusually broad for a project this young: Codex, Cursor, Claude Code, OpenClaw, OpenCode, Hermes Agent, and a Custom option where you hand it a command template like my-agent run --workspace {workspace} --prompt-file {prompt_file}. Mentor model keys (OpenAI, Anthropic, Gemini, OpenRouter) live in ~/.agent-apprenticeship/.env.local, so the apprentice and the mentor can come from different providers.
A first run looks like this:
apprentice run "Create a short market map for AI procurement tools."
apprentice watch <run_id>
When it finishes, the tool prints a local run folder and an Experience Compilation path. You then inspect it, check the bundle, and export the full compilation:
apprentice ecosystem inspect <experience_compilation_path>
apprentice ecosystem export <experience_compilation_path> --full
The part that closes the loop is apprentice learn install, which takes a prior compilation and makes it available as "Runtime Training" for a future run. Loop depth is bounded by a setting, or AA_MAX_ITERATIONS for a one-off session, which suggests the authors have thought about runaway iteration.
The dataset is the real center of gravity
The code is a harness. The substance sits in the seed dataset, published on Hugging Face as agent-apprenticeship-seed-dataset_v0.2. The README lists 500+ curated seed tasks grounded in real-world work, 495 reusable lessons, 1000+ full execution traces, 1000+ task rollouts, 505 full experience compilations, and 39k+ structured records. Take the counts as the authors' figures rather than independently verified ones, but the shape is clear: this is an attempt to bootstrap a corpus of what agents did on specialized, economically valuable tasks, not just chat transcripts.
That focus on economic value is the distinctive angle. The README repeatedly ties the project to "the future of work" and claims the system can estimate task-level economic value per execution. There is no methodology in the README for how that estimate is produced, so treat it as a stated ambition. Still, the choice to organize learning around real tasks with a value dimension, rather than benchmark scores, is a genuinely different framing from most agent-eval projects.
Where to be skeptical
The README is heavy on ecosystem vocabulary and light on internals. Terms like "workflow-family mirrored transfer tasks" appear in the selected_ale_tasks_demo/ reference without definition. The repo structure is a bare list (bin/, src/, schemas/, examples/, selected_ale_tasks_demo/), and there is no description of how mentor evaluation actually scores work, how contributed signals are validated before entering the public ecosystem, or what privacy controls apply beyond a "Private Internal Only" contribution mode. For a system whose whole premise is pooling real work traces, those are the questions that matter.
What agent-apprenticeship gets right is the primitive: treat a finished task as durable, portable experience, and give it a CLI verb (learn install) that feeds it back in. If the dataset holds up to inspection, the harness is worth a run against your own agent stack. Just go in reading the economic-value and compounding-learning claims as the authors' pitch, and verify the traces yourself.
GitHub: https://github.com/Forsy-AI/agent-apprenticeship
Curated by Agent Palisade — practical AI for small and mid-sized businesses.
Top comments (0)