AI curriculum
Course outline for Harness Engineering
Start with existing agent environments such as Claude Code, OpenCode, and ChatGPT Desktop. Study how they expose tools, supply context, retain information, and control actions through documented interfaces and observable behavior. Create an Agent Skill and investigate progressive disclosure. Then use what you learned to assemble a small custom harness with tools, explicit state, permission checks, and a bounded execution loop.
Harness Engineering Course Objectives
- Compare existing harnesses and distinguish model, client, tools, and host responsibilities.
- Author and validate an Agent Skill using the open format.
- Explain and demonstrate metadata discovery, instruction activation, and on-demand resources.
- Trace a real tool integration and identify execution and permission boundaries.
- Distinguish context, session history, saved memory, application state, and checkpoints.
- Build and test a minimal harness using the observed design principles.
Pre-requisites
- Building Applications with LLMs or equivalent competence with model calls, tool integration, context, and storage.
- Write small programs, run tests, use Git, and operate a terminal.
- Basic coding-assistant use helps but Claude Code Engineering–OpenCode and Open Agentic Coding Tools are not prerequisites.
- The course introduces the agent-loop concepts needed for its small build.
Before this course
Complete the required courses or bring equivalent experience. Recommended courses add useful depth; they are not enrolment gates.
Required preparation
Recommended preparation
Readiness checks
- Building Applications with LLMs or equivalent competence with model calls, tool integration, context, and storage.
- Write small programs, run tests, use Git, and operate a terminal.
- Basic coding-assistant use helps but Claude Code Engineering–OpenCode and Open Agentic Coding Tools are not prerequisites.
- The course introduces the agent-loop concepts needed for its small build.
Building Applications with LLMs or equivalent competence with model calls, tool integration, context, and storage.
Find your place in the learning mapLab Setup
Delivery requirements: this environment, access, and the exercise materials must be prepared and verified before delivery. This outline does not certify that a lab package is ready.
A verified stable existing harness with real inference access, Git, a programming runtime/test runner, a disposable workspace, a harmless MCP service, and a small custom-harness scaffold. Provide model/storage adapters, skill validation, and preconfigured isolation appropriate to the benign tests. Validate accounts, costs, permissions, and required features before delivery.
Claude Code, OpenCode, and ChatGPT Desktop are comparison examples, not three mandatory installations or equivalent capability sets. Use at least one actual coding harness for hands-on inspection. ChatGPT's documented macOS Work with Apps behavior is a platform-specific example; do not imply the same integration exists on every desktop OS or that it provides unrestricted shell execution. Use sourced demonstrations or documentation for unavailable platforms. Do not present ChatGPT web MCP features as proven desktop support. No production credentials or confidential personal-memory data are needed.
Detailed Course Outline
Module 1: Learn from existing agent environments (2 hours)
- The harness around the model: The harness around the model: instructions, context, tools, execution, and feedback.
- Claude Code and OpenCode: Claude Code and OpenCode: repository access, commands, sessions, and observed results.
- ChatGPT Desktop: ChatGPT Desktop: documented application integrations and platform-specific controls.
- Execution responsibilities: Compare client, service, provider, model, and operating-system responsibilities.
- Observed tool cycle: Observe a request, tool attempt, actual result, and next response in one environment.
- Evidence and hidden internals: Distinguish visible evidence and documented behavior from inaccessible internal implementation.
- Guided-time allocation: 0.5 hours for explanation and a worked example, 0.75 hours for guided and independent practice, 0.5 hours for checks and feedback, and 0.25 hours for questions and contingency.
Practical outcome: Map an observed tool-backed task and compare the roles of three environments.
Module 2: Agent Skills and progressive disclosure (2 hours)
- Agent Skills format: The Agent Skills open format versus a tool API or a general prompt.
- Skill metadata and instructions: Skill folders, SKILL.md frontmatter, names, descriptions, and task instructions.
- Supporting resources: Supporting scripts, references, assets, dependencies, and relative paths.
- Progressive disclosure: Progressive disclosure: discover metadata, activate instructions, then load needed resources.
- Activation and context cost: Good activation descriptions, non-triggering requests, and context cost.
- Skill validation: Validate the skill and test invocation, resource use, trust, and compatibility limits.
- Guided-time allocation: 0.5 hours for explanation and a worked example, 0.75 hours for guided and independent practice, 0.5 hours for checks and feedback, and 0.25 hours for questions and contingency.
Practical outcome: Create and invoke a skill with one supporting script or reference, without eagerly loading everything.
Module 3: Tool integrations and execution contracts (2 hours)
- Tool integration options: Built-in tools, local functions, external HTTP services, and MCP-mediated tools.
- Tool contracts: Discovery, descriptions, argument schemas, actual execution, and returned results.
- Actual MCP connection: Connect a controlled MCP service in one verified existing harness.
- Read and mutation authority: Read-only and state-changing operations; credentials and tool ownership.
- Tool failures: Invalid arguments, unavailable tools, bounded retries, and truthful failure results.
- Skills and permission: A skill can guide tool use but does not itself grant runtime permission.
- Guided-time allocation: 0.5 hours for explanation and a worked example, 0.75 hours for guided and independent practice, 0.5 hours for checks and feedback, and 0.25 hours for questions and contingency.
Practical outcome: Invoke a real integration and explain who executes and authorizes its operation.
Module 4: Context, memory, permissions, and continuity (2 hours)
- Context selection: Selected files, messages, token limits, compaction, and omitted context.
- History and durable records: Session history, saved preferences, retrieved knowledge, and authoritative application records.
- Memory controls: Memory inspection, correction, retention, and deletion where supported.
- Workspace permissions: Permission rules, approval prompts, workspace access, and sandbox boundaries.
- Host and client boundaries: Host/OS permissions versus client settings and model instructions.
- Checkpoints and resume: Checkpoints, completed effects, interruption, and safe resume conditions.
- Guided-time allocation: 0.5 hours for explanation and a worked example, 0.75 hours for guided and independent practice, 0.5 hours for checks and feedback, and 0.25 hours for questions and contingency.
Practical outcome: Trace what survives a session change and test one allowed and one denied action within documented limits.
Module 5: Build a small harness from the observed patterns (2 hours)
- Model adapter and goal: Choose a model adapter and define a task with an observable completion condition.
- Progressive skill loading: Expose skill metadata and activate instructions/resources only when needed.
- Bounded tool loop: Implement a bounded model/tool loop with validated arguments and explicit results.
- Context and action controls: Add a simple context policy and externally enforced action restrictions.
- Persistence adapter: Use a provided persistence adapter for a task checkpoint and completed-action record.
- Failure and variation tests: Test interruption, resume, denied actions, tool failures, and acceptable output variation.
- Guided-time allocation: 0.5 hours for explanation and a worked example, 0.75 hours for guided and independent practice, 0.5 hours for checks and feedback, and 0.25 hours for questions and contingency.
Practical outcome: Run a custom harness and explain its design using evidence from the earlier modules.
Practical exercise
- Use a synthetic repository-reporting task across the course. First observe it in one accessible existing harness and compare its exposed responsibilities with the documented behavior of the other environments. Record which product, platform, version, and account features were actually available.
- Create a reporting Agent Skill with metadata, concise instructions, a reference, and a small deterministic helper where useful. Validate its format. Demonstrate discovery and activation, inspect when a resource is read, and try an unrelated request. Use visible events or your own instrumented loader where product internals are hidden; do not invent a proprietary client's loading trace. Connect a provided MCP tool and verify its actual output. Inspect a conversation or task handoff and test a harmless permission denial in a disposable workspace.
- Finally extend a minimal harness scaffold to perform the same kind of task. Load skills progressively, call a narrow read tool, and create a local artifact only through an allowed operation. Interrupt and resume from explicit state, and verify the final artifact and completed-action record outside model narration. The learner assembles the control logic; prepared adapters avoid building a client UI, model backend, storage engine, and sandbox within the final module.
Delivery and timing
- Guided hours include explanations, demonstrations, learner practice, checks, feedback, questions, and contingency as allocated above. Breaks, bulk downloads, and prerequisite account/environment setup are additional. These allocations require a timed pilot before delivery; they are not measured completion times.
What you will produce
Create an Agent Skill, inspect an existing coding harness, and assemble a small tool-using harness.
How the work is checked
- The comparison distinguishes documented or observed capabilities from assumed internals.
- The skill meets format requirements and has an appropriate activation description.
- A test shows metadata, instructions, and supporting resources at distinct loading stages.
- A real integration returns an independently checked tool result.
- The learner distinguishes conversation context, saved memory, retrieved facts, and durable task state.
- An unsafe operation is blocked by an actual control, not a persuasive instruction.
- The custom harness completes and resumes a bounded task with verified effects.
- Different acceptable model choices can pass while permission and task constraints remain fixed.
10 guided hours. Observe an existing harness, author an Agent Skill, and extend supplied adapters into a minimal harness. Three product installations are not required. Skill instructions are not a security boundary. Advanced memory, multi-agent scheduling, custom MCP protocol development, and an operating-system sandbox build are excluded.
When another approach is better
- Use a fixed script when the next steps and inputs are already known and do not need agent selection.
- Do not rely on prompts, working directories, or sandbox labels as the sole permission boundary.
How we train
Contact us for full course details, including duration, delivery options and lab requirements.
Ask about exercises, instructor feedback and the prior knowledge you need. Tool-specific courses marked provisional may become modules in a broader course.
Discuss your learning goalsRelated Courses
These courses list this course as preparation.