AI curriculum
Course outline for Agent Execution Environments
Choose where agent code and browser actions run and what they can access. Operate a disposable environment with real file, network, and resource limits. Use a dedicated browser session and inspect its authority. Compare containers, microVMs, isolates, and hosted sandboxes. Share code and data across agents without uncontrolled writes, then verify termination, revocation, and cleanup.
Agent Execution Environments Course Objectives
- Choose code, API, browser, or computer capabilities from task requirements.
- Explain how authenticated sessions and debugging access create authority.
- Compare container, microVM, isolate, and hosted-service boundaries and costs.
- Run a disposable task with configured file, network, and resource restrictions.
- Share common inputs while isolating each agent's code edits and writable state.
- Resolve concurrent-update and integration conflicts through explicit ownership and checks.
- Verify allowed actions, denied actions, and timeout behavior independently.
- Revoke a synthetic session and check processes, files, and retained credentials.
Pre-requisites
- Agentic AI Foundations or equivalent agent-tool and delegated-action competence.
- Command-line use, basic processes/files/network concepts, and small script execution.
- Basic Git branches/diffs and model/tool use; worktrees and sharing policies are introduced.
- Prior Docker knowledge helps; the prepared runtime and essential container concepts are introduced.
- No microVM, kernel, or isolate administration expertise is required.
- No personal authenticated browser or production account is used.
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
- Agentic AI Foundations or equivalent agent-tool and delegated-action competence.
- Command-line use, basic processes/files/network concepts, and small script execution.
- Basic Git branches/diffs and model/tool use; worktrees and sharing policies are introduced.
- Prior Docker knowledge helps; the prepared runtime and essential container concepts are introduced.
- No microVM, kernel, or isolate administration expertise is required.
- No personal authenticated browser or production account is used.
Agentic AI Foundations or equivalent agent-tool and delegated-action competence.
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 prepared disposable lab host, stable Docker or an equivalent restricted runtime, Playwright/browser, synthetic portal with revocable sessions, local test destinations, and a host-side verification script. Keep model credentials outside the restricted task. A prepared agent harness may request the allowed code/browser actions; independent scripted probes test the controls reproducibly. Provide a disposable Git repository, trusted worktree/clone controller, two model-backed workers, per-agent runtime/output paths, and a small state-service adapter with an actual version/transaction or single-writer rule. Use prepared conflict fixtures and inspect base revisions and shared-resource lifetimes. No personal browser, production token, host root mount, privileged container, or container-daemon socket is exposed to the task.
Detailed Course Outline
Module 1: Match capabilities to the task (2 hours)
- Execution capabilities: Code execution, direct APIs, browser control, and computer use.
- Threat model: Task requirements, sensitive data, threat models, and least authority.
- Authenticated browser access: Authenticated CDP access, dedicated profiles, and extension-based integration.
- Display and session boundaries: Headed/headless display choices versus session ownership and permission boundaries.
- Synthetic portal task: Playwright operation against a disposable synthetic portal.
- Narrower alternatives: Broad desktop authority compared with narrower tool access.
- 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: Complete a harmless browser task and identify its data and authority boundaries.
Module 2: Run code inside a restricted environment (2 hours)
- Container basics: Docker basics: image, container, process, mounts, and network.
- Sandbox policy: Sandbox policy versus packaging and model instructions.
- Filesystem and process authority: Non-root execution, read-only inputs, narrow output paths, and capabilities.
- Network and resource limits: Controlled network access, CPU/memory/process limits, and time budgets.
- Actual denial tests: Actual permitted operations and harmless file/network denial tests.
- Shared-kernel risks: Shared-kernel and container-daemon risks not removed by a workspace boundary.
- 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 small transformation and demonstrate independently observed file and network restrictions.
Module 3: Share data without sharing every writable resource (2 hours)
- Shared immutable baseline: Shared code/data baseline, immutable snapshots, and input-version identity.
- Private writable outputs: Common read-only mounts versus per-agent writable workspaces and outputs.
- Worktrees and patch exchange: Git branches, linked worktrees, separate clones, and patch/artifact exchange.
- Competing shared resources: Shared repository metadata, dependency environments, caches, ports, and test data.
- Mutable-state ownership: Mutable state through scoped service APIs, transactions, or a single writer.
- Conflicts and retesting: Lost updates, stale reads, locking/version checks, merge conflicts, and retesting.
- 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 two agents from one code baseline, preserve both outputs, and integrate changes through a controlled owner.
Module 4: Compare stronger and hosted boundaries (2 hours)
- MicroVM boundaries: MicroVMs: guest/host separation, KVM requirements, and lifecycle overhead.
- Isolate boundaries: Isolates: runtime boundaries, available APIs, and process-sharing assumptions.
- Boundary comparison: Containers, microVMs, and isolates against the same task threat model.
- Hosted sandbox services: Hosted sandboxing services: access, data paths, retention, billing, and ownership.
- Pause and destruction: Paused or snapshotted state versus actual destruction and revocation.
- Resource and risk trade-offs: Capability fit, startup/resource trade-offs, and residual risk.
- 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: Choose an environment from sourced evidence without claiming all boundaries were tested locally.
Module 5: Terminate, revoke, and verify cleanup (2 hours)
- Ephemeral lifecycle: Ephemeral environments, task ownership, timeout, and process supervision.
- Retained browser and task state: Browser profiles, cookies, downloaded files, tokens, volumes, and snapshots.
- Session revocation: Application-session revocation versus deleting a local cookie file.
- Termination and cleanup: Actual interruption, child-process termination, and workspace cleanup checks.
- Approved retained outputs: Retained approved outputs versus unintended persistent task state.
- Independent cleanup checks: Independent verification, residual-risk reporting, and cleanup failures.
- 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: Terminate a timed-out task, revoke its synthetic session, and verify designated state cleanup.
Practical exercise
- Use a synthetic portal to download an input file through a dedicated browser session. Process it in a prepared restricted container and retain only the approved output. Before running, map its files, network destinations, session authority, limits, and cleanup owner.
- Demonstrate permitted input/output access, a denied write outside the permitted path, and a denied network destination. Use harmless operations against lab resources, not exploit code or the learner's host. Trigger a timeout with a bounded sleeper and inspect actual task/container processes after termination. Revoke the synthetic server session and verify the old session no longer works. Check browser shutdown, profile/download cleanup, task workspace, and designated volumes. Preserve expected output separately. Report exactly which protections were exercised and which remain assumptions.
- Add a small two-agent code exercise over the same repository baseline. Both agents can read the common reference data, but each edits a separate linked worktree or clone and writes its own test/output artifacts. Record the base revision and environment versions. Keep the trusted Git controller outside restricted agent containers when linked-worktree metadata needs broader access. A worktree is not itself a security boundary.
- Review and integrate the two patches into a disposable target under one merge owner. Exercise a prepared overlapping change or stale-base case and rerun the combined tests; separate passing branches do not establish integration correctness. Use a provided state service to demonstrate a concurrent update with a version check or serialized writer, rather than letting agents overwrite one shared JSON file. The agents use actual model-backed code/tool operations; small fixtures make conflicts and stale updates reproducible.
- During cleanup, remove only the finished agent's private resources. Check that the other agent's workspace and approved shared data remain usable. Track shared volumes and services separately from per-agent scratch state.
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
Run restricted agent work, coordinate shared resources, and independently verify permissions and cleanup.
How the work is checked
- Capability selection follows a stated threat model and explains narrower alternatives.
- The browser task and container task actually execute in designated lab environments.
- Real file/network controls deny the harmless forbidden operations.
- Two actual agents use the same baseline without overwriting private edits or outputs.
- The merge owner checks base revisions, resolves the prepared conflict, and retests integration.
- A shared-state update uses the stated concurrency policy rather than silent last-write-wins.
- One agent's cleanup preserves shared resources and the other agent's workspace.
- Resource settings and timeout outcomes have independent runtime evidence.
- Cleanup checks inspect task processes, workspace state, and browser artifacts.
- The revoked synthetic session fails at the application, not just in local storage.
- Comparison distinguishes measured local controls from documented vendor behavior.
- The report does not equate an ephemeral label with secure deletion or complete isolation.
10 guided hours. Actual restricted execution and concurrent sharing tests use a prepared disposable runtime. The course introduces essential container concepts. Stronger hosted, isolate, and microVM options are sourced comparisons, not required installations. Shared resources retain explicit owners; cleanup must not delete other work. No personal browser session or production credential is used.
When another approach is better
- Use a restricted API instead of browser or computer control when it exposes the necessary capability with narrower authority.
- Do not select a complex microVM or hosted sandbox without a threat or resource need that justifies its operating cost.
- Do not run untrusted tasks in an authenticated personal browser or an environment whose restrictions are only described in prompts.
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.