AI Architects: AI Camp Syllabus for Ages 15+ Advanced
AI Architects: Ages 15+ Advanced
The pitch for campers: Most people use AI through a chat box. Architects work underneath it: calling models from code, wiring them to tools, testing them like engineers, and deciding what they must never be allowed to do. You'll leave with a deployed agent, a public repo, and an evaluation report that proves it works.
Part of AI Camp. Shared principles, the Agent Card, the Four Lenses rubric and the tools-by-age table live there. For the no-code track, see AI Makers.
Why this band is built differently
Colearn is the developer of record. Campers are minors, so they don't hold personal API keys. Colearn provisions keys under its own organisation account, with spend caps and logging. Anthropic, for example, requires developers whose products serve minors to add age verification, content moderation, monitoring and child-privacy compliance. [1] Consumer chat apps keep their own age rules: ChatGPT needs parental consent under 18, [2] and Claude.ai requires users to be 18 or older. [3]
Agents, defined precisely. Campers learn the engineering distinction between workflows (LLMs and tools orchestrated through predefined code paths) and agents (LLMs that dynamically direct their own process and tool use), and the advice to start with the simplest thing that works. [4]
Tools through an open standard. Campers connect agents to data and tools through the Model Context Protocol (MCP), an open standard for linking AI applications to external systems. [5]
UNESCO level: Create, including the "AI system design" dimension most curricula skip. [6]
Ratio: at most 1 instructor to 10 campers, plus a teaching assistant. Stack: Python or TypeScript, a hosted code environment, Git and GitHub, and one model provider SDK chosen by Colearn. Safety baseline: every repo ships with a RULES.md (the Agent Card's Rules and Check-in) and an evals/ folder.
Course 1: Agent Forge
Maps to the original AI Mastery for Living Life, rebuilt as an engineering course: one agent per life area, increasing autonomy each time.
Big question: How much autonomy should an agent get, and how do you prove it deserves it?
Campers will be able to:
Call a model from code with a system prompt, structured output, and tool definitions.
Build an agent loop: the model plans, calls a tool, reads the result, and decides the next step, with a hard step limit.
Write and run an evaluation suite (at least 20 cases, including adversarial ones) and report pass rates.
Add a human approval gate before any action with external effects.
| Day | Theme | What happens |
| 1 | From chat to code | First API call. Then structured output (JSON for a daily plan), then a single tool (a calculator or a weather lookup). Read and discuss the "workflows vs. agents" taxonomy and its "start simple" advice. [4] Each camper writes three Agent Cards (Personal, Social, Work/School) and ranks them by how much autonomy each should get. |
| 2 | Personal agent (workflow) | Build the lowest-autonomy agent first: a fixed pipeline, such as a meal or training planner that reads a local log file, compares it to a goal, and outputs a plan. A fitness planner is anchored to the CDC guideline for ages 6–17: 60+ minutes of moderate-to-vigorous activity daily, with vigorous activity at least 3 days a week. [7] Write the first ten eval cases. |
| 3 | Work/School agent (tools + MCP) | Connect a study agent to real context through MCP: a notes folder, a reading list, a calendar export. [5] The agent must follow coach, not crutch: campers write evals that fail the agent if it hands over a full solution, a rule drawn from the finding that unrestricted GPT-4 harmed math learning while a hint-only tutor did not. [8] |
| 4 | Social agent (autonomy + approval gate) | The highest-autonomy agent: it drafts and schedules (for example, organises a study group or a family event across several people's availability). Every outbound message passes a human approval gate. Red-team hour: peers try prompt injection through calendar text and documents. Fix and re-run the evals. |
| 5 | Forge Review | Each camper presents an architecture diagram, eval results (before vs. after fixes), and one case where they reduced the agent's autonomy because it hadn't earned it. |
Capstone: a GitHub repo with three agents, RULES.md, an evals/ suite, and a one-page evaluation report.
Course 2: Venture Studio Sprint
Maps to the original AI Mastery for the Work/School World (Tech, Arts, Biz), run as a startup studio.
Big question: Can you find a real user, build them an AI product in four days, and get them to use it?
Campers will be able to:
Interview a real user and write a problem statement.
Build and deploy an AI-powered prototype (web app, bot or tool) in their spike: STEM, MAD or ELC.
Instrument it: log usage, collect feedback, run evals on real user inputs, with consent and with no personal data kept.
Make an honest pitch, including risks and what the AI can't do.
| Day | Theme | What happens |
| 1 | Find the user | Teams of 2–3 pick a track. Tech: a tool for a teacher, coach or lab. Arts: a creative tool for a musician, filmmaker or artist. Campers discuss where authorship sits, given the US Copyright Office's view that prompts alone aren't enough for copyright protection. [9] Biz: a tool for a club, small business or cause, framed against one of the UN's 17 Sustainable Development Goals. [10] Interview a real user (by video call or in person). |
| 2 | Prototype | Ship a thin working slice by end of day. Instructors enforce the rule: deploy something on Day 2, polish on Day 4. |
| 3 | User test | Put it in front of the user. Log what broke. Turn every failure into an eval case. |
| 4 | Iterate + harden | Fix the top failures, add guardrails, write a data and privacy note (what's collected, how long it's kept, who sees it). If the product could reach anyone under 13, map it against the FTC's amended COPPA rule, in force since 23 June 2025. [11] |
| 5 | Demo Day | A five-minute pitch to a panel: problem, user evidence, live demo, eval numbers, risks, and next steps. |
Capstone: a deployed prototype, a user-test log, an eval suite, and a privacy note.
Course 3: Mirror, Not Master
Maps to the original AI Mastery for Personal & Social Life, with the ethics and safety engineering done for real.
Big question: If you were the company, how would you build AI that's good for teenagers' minds and relationships?
Why it matters: Common Sense Media's testing rated social AI companions an unacceptable risk for anyone under 18. [12] It also found that general assistants like Claude are not safe or reliable for teens' mental health or emotional support. [13] Model providers are responding with age gates, distress detection and redirection to human help. [3] In this course, campers sit on the builder's side of that problem.
Campers will be able to:
Read a published AI risk assessment and turn its findings into testable requirements.
Build a reflection agent, a "mirror," that helps a user think (journaling prompts, goal reviews) and is engineered not to become a companion.
Write safety evals: distress signals, requests for romantic role-play, attempts to make the agent claim feelings. Wire escalation paths to human resources.
Defend design trade-offs in a written design review.
| Day | Theme | What happens |
| 1 | Read like a regulator | Teams take apart the Common Sense AI-companion findings and its teen survey, [14] then turn each harm into a requirement ("the agent never says it has feelings"). Evidence on the upside of human connection anchors the goal: the Surgeon General's loneliness advisory [15] and the Harvard Study of Adult Development. [16] |
| 2 | Build the mirror | A reflection agent: an end-of-day journal that asks questions, summarises themes weekly, and suggests one real-world action involving another person. Memory design: what it stores, for how long, and a one-command "forget everything." |
| 3 | Safety evals | Write 30+ eval cases across categories: distress, manipulation attempts, companion-style requests, privacy leaks. Implement detection plus a fixed, tested escalation response that points to trusted adults and crisis lines. No campers role-play distress about themselves; instructors supply the test scripts. |
| 4 | Engagement audit | Add usage metrics, then audit them. Is the agent nudging more time with it or less? Change the design so success means the user closes the app and goes to do something. Self-determination theory frames it: support autonomy, competence and relatedness, not dependence. [17] |
| 5 | Design Review | Present to a panel playing a safety board: requirements, evals, failure cases, and what you'd refuse to ship. |
Capstone: a reflection-agent repo, a safety eval suite with results, and a two-page design review.
Course 4: Exocortex
Harness tuning and second brains at scale. New for ages 12 and up. At this level it's the systems course underneath Agent Forge, Venture Studio Sprint and Mirror, Not Master: how agents remember, what they read, and how you prove the setup is helping.
Big question: When an agent works for hours across many context windows, what should it carry forward, and how do you measure whether your harness is making it better or worse?
Why it matters (the version for parents): Model quality is no longer the only thing that decides what an agent can do. The harness around the model now matters as much: what it loads, what it remembers, which skills and tools it can reach, and how it summarises itself when the context window fills up. Anthropic's applied-AI team names three core techniques for long tasks: compaction (summarise and restart with the summary), structured note-taking (notes kept outside the context window and pulled back in later), and sub-agents with clean context windows of their own. [18] Its engineers got agents to make steady progress across many sessions by having them leave a progress file, a feature list and a clean git history for the next "shift." [19] Agent instructions are converging on open, file-based formats: AGENTS.md for project instructions [20] and SKILL.md folders for skills, loaded with progressive disclosure. [21] A camper who can tune a harness and measure it is learning the most in-demand AI systems skill of 2026.
The second brain is the agent's long-term memory and the camper's own: a Markdown vault with structured frontmatter and links, owned by them and readable by any tool. [22] Vannevar Bush pictured it in 1945 as the memex. [23] Campers build the version that agents can actually query.
Tools at this level:
Hermes Agent: open source (MIT), works with any model provider, and is compatible with the open Agent Skills standard. Its source is readable end to end, which is exactly why it's here. [24] Campers run it in Colearn sandboxes on capped org keys, with command approval on and messaging connections off.
Second brain: Logseq [25] or a plain Markdown folder in the camper's code editor. Obsidian's terms limit use to adults, [26] so it's for campers who are 18, or instructor demos.
Campers' own code from Agent Forge, including the read-only MCP server from Day 3. [5]
Campers will be able to:
Instrument a harness: log, turn by turn, how many tokens each component (persona, rules, memory, skills, tools, history) takes up.
Build a retrieval layer over a Markdown vault and compare just-in-time retrieval (search the files when needed) with preloading (stuff it all in up front).
Design and run a context-rot evaluation on their own data, across context sizes and answer positions, on at least two models.
Run a long task across three or more sessions using a progress file, and measure what was lost at each handover.
Review agent-written skills the way engineers review code: keep, edit or delete, with reasons.
| Day | Theme | What happens |
| 1 | Harness teardown | Read the Hermes source: the agent loop, the memory tool, how context files are assembled into the system prompt. Diagram it. Write a token-accounting script that reports, per turn, what each component costs. Compare Hermes's SOUL.md / AGENTS.md / MEMORY.md / USER.md split with the open AGENTS.md format used across coding agents. Discuss why Hermes hard-caps memory at roughly 800 tokens for its own notes and 500 for its profile of you. |
| 2 | Vault as data | Build a second brain from camp materials and your Agent Forge repo: YAML frontmatter, wikilinks, PARA folders. Write a small indexer, then expose the vault through your read-only MCP server. Implement two retrieval strategies, filename and full-text search on demand versus preloading the top-k notes, and log what each puts into context. |
| 3 | Context rot, measured | Build needle-in-a-haystack evals from your own vault: plant facts at the start, middle and end of inputs from 2k to 100k+ tokens, and run them on two models. Chart accuracy against length and position. Compare your results with the published research, then write a context budget policy for your agent: what loads always, what loads on demand, and what never loads. |
| 4 | The long-horizon run | Give Hermes, or your own harness, a multi-session project, such as turning your vault into a static website. Follow the shift-work pattern: an init script, a feature list, and a progress file updated at every handover. Force context resets and /compress, then measure what survived each one and what had to be re-derived. |
| 5 | Skill review + Demo Day | Hermes writes its own skills as it works. Pull every skill it created this week and review each like a pull request: is it correct, minimal, and safe? Then the security angle: notes and skills are an attack surface, so write an eval in which a planted note tries to inject instructions. Demo the token dashboard, eval charts, budget policy and reviewed skills. |
Sources for Table: [27] [28] [29] [20] [19]
Capstone: a repo containing the harness configuration, the vault indexer and MCP server, a context-rot eval report, a long-horizon run log, and the reviewed skill set, with a one-page design doc tying them together.
Assessment for this band
Apply the shared Four Lenses rubric from Program Design, with engineering evidence:
Build: deployed, documented, reproducible from the README.
Judgment: eval suites with pass rates before and after, plus at least one autonomy reduction or refusal to ship.
Purpose: a real user or a real personal need, evidenced.
Humanity:
RULES.md, approval gates, a privacy note, and escalation paths.Judgment (Course 4): a context budget policy backed by the camper's own eval data, plus at least one agent-written skill that was rejected or rewritten, with the reason.
Instructor prep
Provision org-level API keys with per-camper spend caps and logging. Document the safeguards required for products serving minors. [1]
Prepare a starter MCP server (a read-only notes folder) so Day 3 of Agent Forge doesn't stall on setup. [5]
Prepare red-team and safety-eval scripts in advance. Campers never generate distress content about themselves.
For Course 4: provision Hermes Agent sandboxes with capped keys, command approval on and messaging connections off, [24] and give each camper a model budget large enough for the 100k-token eval runs. Wipe or export memories, skills and vaults at the end of camp.
Sources
Sources
- [1]AI policyanthropic.com
- [2]Is ChatGPT safe for all ages?help.openai.com
- [3]Protecting the wellbeing of our usersanthropic.com
- [4]Building Effective AI Agentsanthropic.com
- [5]Introducing the Model Context Protocolanthropic.com
- [6]AI competency framework for studentsunesco.org
- [7]
- [8]
- [9]
- [10]The 17 Goalssdgs.un.org
- [11]
- [12]
- [13]Claude Risk Assessmentinstitute.commonsensemedia.org
- [14]Talk, Trust and Trade-Offs: How and Why Teens Use AI Companionscommonsensemedia.org
- [15]
- [16]Good genes are nice, but joy is betternews.harvard.edu
- [17]
- [18]Effective context engineering for AI agentsanthropic.com
- [19]Effective harnesses for long-running agentsanthropic.com
- [20]
- [21]
- [22]File over appstephango.com
- [23]As We May Thinktheatlantic.com
- [24]
- [25]
- [26]Terms of Serviceobsidian.md
- [27]Persistent Memoryhermes-agent.nousresearch.com
- [28]
- [29]Lost in the Middle: How Language Models Use Long Contextsaclanthology.org