ADVANCED AI TEACHERS LAB / 9 PRACTICAL LAYERS

Build Your
Agentic OS.

Create a self-improving AI operating system you can actually inspect—using Claude Fable 5.1 where justified, cheaper evaluated models for routine work, independent quality checks, strict permissions and human control.

Free written course · 5–7 hours of self-paced practice · No account required · Technical lab optional

Illustrative editorial image of colleagues reviewing documents at a desk
Illustrative scene, not an actual student or workshop.
9 guided layersPython no-key local lab30-day rollout planHuman approval by design
THE CONTROL PLANE

Give every role a job.
Give no role unchecked power.

The planning agent cannot authorize its own work. The worker produces a proposed artifact. Verification checks original evidence independently, and the gate enforces allowed actions and budget before a human decides what happens next.

01PlannerRead-only intent
02WorkerDraft-only result
03VerifierTests evidence
04Policy gateBudget & permissions
05Human ownerAccept, revise or stop
Feedback loop Evidence + exception logs + measured outcomes improve the next version. No self-editing production instructions without review.
ACTUAL WORKING CODE / WITHOUT API KEYS

Run the control system before connecting your accounts.

This original standard-library Python lab demonstrates source checking, bounded simulated spending, duplicate protection, a human audit ledger, prompt-injection refusal, and a re-verification command. It runs locally and does not call Claude or execute external actions.

Technical practice uses Python 3.10+. Non-coders can follow the nine layers and use the downloadable workbook without running the script.

local-agentic-os / training only
python3 agentic_os.py --state ./lab-state run --task demo-safe.json

python3 agentic_os.py --state ./lab-state monitor

python3 agentic_os.py --state ./lab-state report

Expected: a verified local draft needing human review, not an automatic deployment.

OPERATING ECONOMICS

Calculate cost per accepted result, not cost per prompt.

Change the assumptions below to compare model token spend and review labor. These are examples, not observed savings. Token prices are a dated October 25, 2026 reference from Anthropic pricing, excluding caching, tools, retries and platform fees.

Estimated model tokens / month—
Token spend / month—
Tokens per accepted output cost—
Model + review labor—
Illustrative baseline less total—

This is a scenario calculator, not a guaranteed ROI projection. It excludes setup, governance, security, failures, external fees and variance in actual token use. Human review is never assumed to disappear.

CAPSTONE / 30 DAYS

Scale only what your evidence supports.

01 / DAYS 1–7

Define & protect

Choose one outcome, baseline it, write policy and make a low-risk dry run.

02 / DAYS 8–14

Supervise & learn

Review every output, record issues, fix unsupported claims and track review time.

03 / DAYS 15–21

Stress-test

Test missing evidence, poisoned source material, budget limits and duplicate requests.

04 / DAYS 22–30

Decide together

Review accepted outcomes and full costs; keep, adjust or stop—with an owner.

NINE ORIGINAL LESSONS

Your Agentic OS, one verified layer at a time.

Choose the founder track or the technical lab. Both end at the same checkpoint: human-observable evidence of a safe, useful result.

Your course progress

0 of 9 activities checked

Only checkmarks are saved in this browser. Your task data is never submitted to this site.

LAYER 01 / 25 minutes

Define the loop before buying tools

Start with one business result that can be measured independently of the model's opinion.

Our running example is a fictional software team's weekly customer-feedback digest. We are not trying to replace a company with a prompt; we are building one low-risk process with inputs, an owner, an evidence trail and a useful output.

Build it step by step

  1. Choose one repeatable responsibility (for example: collect product feedback and propose documentation fixes), and write down the current human process.
  2. Specify the trigger, approved sources, intended recipient, desired output and action that stays manual.
  3. Choose three success metrics: evidence coverage, reviewer time and accepted recommendation rate.
  4. Define a failure condition and when a human must stop the loop.
Your deliverable

A one-page loop map and baseline comparison to the manual process.

Choose your learning path

Founders: map a marketing or customer-support loop. Builders: map a narrow issue-to-PR preparation loop.

Practice with AI

COPYABLE LEARNING PROMPT
You are helping design an AI-assisted operations workflow, not operating it yet. For the fictional weekly customer-feedback digest, draft a loop map: input → analysis → proposed action → independent check → human decision → feedback for next run. Define three measurable quality metrics and two explicit reasons to stop. Keep all publishing and customer contact human-approved.
Independent checkpoint

Can another person tell whether the result was useful without asking the AI to grade itself?

Important: A business improving 'while you sleep' is an aspiration, not evidence that unattended actions are safe.

LAYER 02 / 35 minutes

Write rules the system can actually enforce

A constitution is only useful when critical rules are implemented in code, policy or platform permissions.

Use the included constitution.json to specify allowed task types, maximum estimated spend, output requirements and external-action policy. A free-form prompt can describe your values; it cannot enforce an operating-system permission boundary by itself.

Build it step by step

  1. Open constitution.json from the free code kit and inspect the approved task types and daily budget.
  2. Write three machine-checkable rules: no external actions, limit the cost of one run, and reject unsourced claims.
  3. Write three editorial preferences separately: concise tone, clear headings and friendly wording.
  4. Run the local demo with the default rules, then reduce its daily cap and observe the refusal.
  5. Document who is allowed to change the policy file and how changes are reviewed.
Your deliverable

Policy file, rule-to-test map and an explicit exception process.

Choose your learning path

Founders: define spending and approval authority. Builders: implement deny-by-default permissions.

Practice with AI

COPYABLE LEARNING PROMPT
Turn these operating principles into two columns: (A) rules that need enforced technical controls and (B) writing preferences that can remain prompts. Principles: never publish without approval; cite every source; keep spend below our daily limit; write clearly; never reveal secrets; avoid duplicate requests. For each technical rule, give a test that would prove enforcement.
Independent checkpoint

Does a budget- or permissions-violating run fail even if the planner asks nicely?

Important: A model can misinterpret a rule. Run critical checks outside the model.

LAYER 03 / 40 minutes

Separate planning, doing, reviewing and approval

Avoid letting the same agent invent work, claim success and approve the release.

Use distinct components: planner drafts a constrained plan, worker prepares an artifact, independent verifier tests evidence, and policy gate decides whether a human can review it. For a real deployment, isolation requires separate credentials and runtime boundaries.

Build it step by step

  1. Draw four lanes: plan, execute, verify, authorize.
  2. Give the planner read-only access and the worker only a sandbox or draft destination.
  3. Define the verifier's input as the original sources plus output artifact, not the worker's success claim.
  4. Keep the authorizing gate deterministic and the human approver identified by role.
  5. Run the simulated agentic_os.py program; inspect its stage-by-stage results.
Your deliverable

An architecture drawing and enforceable permissions table.

Choose your learning path

Founders: assign real accountability. Builders: design separate identities and token scopes.

Practice with AI

COPYABLE LEARNING PROMPT
Draft a four-role RACI matrix for a fictional feedback-digest agent. Planner may propose work; worker may prepare a draft; verifier independently checks sources and completeness; policy gate checks budget and permissions; human approves external publication. List credentials, allowed actions, blocked actions, and how to test each boundary.
Independent checkpoint

Can the planner write to production or can the worker declare its own output verified? The answer must be no.

Important: Our starter separates stages in functions for learning. It is not a hardened security sandbox.

LAYER 04 / 40 minutes

Route work to the right model and control cost

Use expensive reasoning only where it improves independently measured outcomes.

Anthropic now lists Fable 5.1, Opus 5.5, Sonnet 5.5 and Haiku 5.5 at materially different token prices. Routing should use empirical quality tests and task risk, not price alone. The academy's interactive estimator is illustrative, not a provider invoice.

Build it step by step

  1. Estimate input tokens, output tokens, attempts and weekly workload for a sample task.
  2. Compare a Fable-only scenario to an evaluated mixed-model scenario in the cost estimator.
  3. Try a simple rule: use the least costly tested model meeting your quality threshold.
  4. Add hard call-count, token and daily-spend guards in the application layer before making API requests.
  5. Read the current provider documentation for caching and task budgets; label advisory limits clearly.
Your deliverable

Routing decision table, expense estimate and fallback plan.

Choose your learning path

Founders: compare cost per approved brief. Builders: add metering before vendor calls and reconcile against provider billing.

Practice with AI

COPYABLE LEARNING PROMPT
Design a model-routing policy for three task types: low-risk classification, documented drafting, and novel architecture review. Recommend evaluation criteria rather than blindly assigning a specific model. Include token estimates, cache strategy, fallback, and conditions where the task should stop for human help.
Independent checkpoint

Can you show cost per accepted result, not just cost per generated token?

Important: Claude API task_budget is advisory, not a billing ceiling; the demo's spend cap applies only to its own estimated, simulated activity.

LAYER 05 / 45 minutes

Make 'done' a verifiable state

Treat the artifact, sources, tests and review record as evidence. Never trust a completion claim by itself.

Our demo produces a draft from a set of fictional source records. A separate verifier checks evidence coverage and an approvals rule. In a real software task, checks could include unit tests, diff review and a smoke test; in marketing, source validation and human approval.

Build it step by step

  1. Run a normal fixture and locate the proposed output in the local run ledger.
  2. Compare every claim to its cited source and check that no owner/date was invented.
  3. Run the incomplete or malicious fixture; inspect the independent failure reason.
  4. Test one intentionally incorrect statement in your own fictional input and ensure it is flagged.
  5. Record accepted, rejected and needs-review states distinctly.
Your deliverable

Review rubric, passing example and failure example.

Choose your learning path

Founders: audit a proposed customer communication. Builders: use tests and externally inspected artifacts.

Practice with AI

COPYABLE LEARNING PROMPT
Create an independent verification rubric for a weekly feedback digest: source coverage, no unsupported claims, clear action owner, human approval, safe handling of missing data. Provide five test cases, a pass/fail decision for each and the evidence an auditor must inspect. Do not treat the generator's self-assessment as a test result.
Independent checkpoint

Can the worker's claim of success be contradicted and rejected by an independent check?

Important: A second language model is not automatically independent; prefer objective tool outputs, immutable evidence and human audit where appropriate.

LAYER 06 / 35 minutes

Add a heartbeat without creating an endless loop

Review whether previously accepted work is still valid while keeping bounded checks, expiry and clear ownership.

Some outputs expire quickly. A weekly status brief is stale next week; a launched feature may break after a dependency update. Monitoring should recheck defined conditions on a schedule, not continuously consume tokens or repeat consequential actions.

Build it step by step

  1. Pick what has to remain true for your output to stay valid.
  2. Define a reasonable check interval and a maximum number of retries.
  3. Separate detecting an issue from fixing it; alerts and proposed patches require human decisions.
  4. Run agentic_os.py monitor against the local evidence ledger.
  5. Document how the system marks outcomes stale and when a responsible person is notified.
Your deliverable

A scheduled verification plan and exception escalation tree.

Choose your learning path

Founders: define business process alerts. Builders: design cron or event triggers only after safe dry runs.

Practice with AI

COPYABLE LEARNING PROMPT
Design a bounded monitoring plan for a fictional support-knowledge-base update. List checks that can be done cheaply without AI, when to escalate, the maximum checks per day, when to stop, and the owner of each alert. Avoid any unchecked self-triggering loop.
Independent checkpoint

Can monitoring stop safely when a source or budget is unavailable?

Important: The included monitor command rechecks saved demonstration evidence; it does not contact live websites, production systems or customers.

LAYER 07 / 35 minutes

Earn autonomy from audited performance

Increase delegation only after repeatable, human-reviewed results, with immediate escalation when quality declines.

The kit demonstrates an illustrative promotion threshold of at least 20 independently reviewed runs with at least 95% passing. This is a teaching policy, not a universal safety standard; high-impact work may require stricter thresholds and formal governance.

Build it step by step

  1. Run several simulated tasks and note that self-verification alone cannot raise the trust level.
  2. Use the audit command to record human review outcomes and names in the local training ledger.
  3. Introduce a failed audit and confirm that eligibility to use less supervision is removed.
  4. Create levels such as draft-only, supervised-tool-use and human-reviewed execution.
  5. Define tasks that always require approval, regardless of past performance.
Your deliverable

Trust ladder, signed-off audit policy and revocation test.

Choose your learning path

Founders: define who approves expanded authority. Builders: store append-only, access-controlled audit events.

Practice with AI

COPYABLE LEARNING PROMPT
Design a reversible autonomy ladder for a weekly operations assistant. Include draft-only, supervised, and narrowly delegated modes. Require independent audits, define a quality threshold, revoke eligibility on any critical error, and keep client contact, spending and production changes human-approved.
Independent checkpoint

Does a failed human audit trigger review instead of letting the agent continue on past reputation?

Important: Do not treat sample review counts as actuarial guarantees. Protect real audit logs from tampering.

LAYER 08 / 45 minutes

Defend the boundary between data and instructions

Treat retrieved documents, tickets, emails and logs as untrusted inputs that must not issue new commands.

Prompt injection occurs when untrusted content attempts to change system behavior. The training fixture includes a harmless example of an instruction hidden inside a support note. The sample filters it as evidence, not an instruction; real systems need deeper controls.

Build it step by step

  1. Open the malicious demonstration fixture and identify the instruction that does not belong to the support evidence.
  2. Run the fixture and check that it is rejected without executing commands or sending data.
  3. Write a least-privilege secrets plan: no API keys in prompts, logs or committed files.
  4. Document an incident runbook for credential exposure, cost spike, repeated failures and attempted prompt injection.
  5. Create a pause procedure that can shut down job triggers and revoke credentials.
Your deliverable

Threat model, defensive test results and incident response runbook.

Choose your learning path

Founders: practice incident escalation. Builders: enforce access controls outside the model and limit tool execution.

Practice with AI

COPYABLE LEARNING PROMPT
Threat-model a customer-feedback agent that reads outside submissions and drafts an internal report. Include prompt injection, poisoned sources, secret leakage, excessive tool permissions, repeated job triggers and misleading completion reports. Recommend defense-in-depth controls and two safe test fixtures, with owner and stop condition.
Independent checkpoint

Do untrusted source notes remain data, even when they contain a direct command?

Important: Pattern detection in the demo is intentionally simple and cannot guarantee full prompt-injection protection.

LAYER 09 / 50 minutes

Run a 30-day pilot and test the economics

Scale verified outcomes, not the number of agents, tokens or impressive demos.

The 30-day plan introduces one task at a time, tracks cost per accepted output, keeps detailed failure notes and expands only with evidence. ROI calculations subtract setup, review, correction, vendor and maintenance costs; no savings are guaranteed.

Build it step by step

  1. Days 1–7: design the loop, choose a low-risk fixture, set policy and baseline manual effort.
  2. Days 8–14: run under manual review, log failures and improve evidence quality.
  3. Days 15–21: test a second input class, verify costs and deliberately try failure cases.
  4. Days 22–30: hold a go/no-go review; document trusted tasks, open risks and follow-up ownership.
  5. Compare measured time, error rates and provider costs against the original process.
Your deliverable

30-day scorecard, go/hold/stop decision and an accountable operating owner.

Choose your learning path

Founders: calculate contribution after cost and rework. Builders: document model switching, schema versioning and rollback.

Practice with AI

COPYABLE LEARNING PROMPT
Evaluate whether our fictional AI feedback workflow is ready to progress after 30 days. I will provide runs, human-review times, failure counts and estimated API spend. Calculate accepted-result rate, cost per accepted result, review burden and unresolved risks. Give a go/hold/stop decision with evidence and a clearly assigned human owner. Do not assume productivity gains not supported by the data.
Independent checkpoint

Would you still operate the system if it produced fewer but higher-quality results?

Important: The economics of agentic labor differ by task, quality, compliance, tool setup and human oversight.

You have built the operating logic.
Now test it on your own terms.

Download the workbook and lab, test a fresh example, and seek human approval before connecting tools or granting write access.

DOCUMENTED, NOT HYPED

What’s real, what changes, and what needs testing.

Models

Fable 5.1 is a powerful, relatively expensive option. Start with a less costly model that passes your own evaluation; the course design is model-replaceable.

Spending controls

Claude API task budgets are advisory. Use a real metered admission gate and reconcile usage; local demo caps are simulated.

Trust & autonomy

The 20 audited runs / 95% threshold is illustrative, not a universal standard or assurance of safety. Sensitive actions require approval even after a run passes.

Source reading and related material

Further viewing: Y Combinator: How to Build a Self-Improving Company with AI, a public presentation by Tom Blomfield. Our training materials and examples are original and do not reproduce a third-party paid guide.

BRING THIS INTO YOUR TEAM

From a course exercise to a responsibly managed business workflow.

Use the existing private AI Working Session to map one real responsibility. For teams, Waymaker Agency offers tailored workshops and implementation guidance. Neither option promises autonomous operation or guaranteed savings.