Secure an Engineering Agent, From Task to Release
Build a connected review packet for a fictional maintenance agent. Define task and delegated authority, review workspace changes, reconcile uncertain effects, govern reusable memory and defend a bounded release decision.
An engineering agent can prepare a useful patch while still being forbidden to publish it, read another project’s files or change the rules that constrain its tools. This course makes those distinctions concrete through a fictional documentation-maintenance workflow.
You will follow one task from its initial grant through delegation, workspace review, approved publication, reusable memory, cancellation and release evaluation. Each lesson adds an artifact to the same review packet. The final project asks you to decide what can enter a bounded pilot, using evidence that includes both successful checks and unresolved problems.
The course applies mechanisms taught in the concept library. Its purpose is to make their interaction testable: a valid signature does not supply missing authority, a good patch does not establish safe test execution, and an accepted publication request does not settle an uncertain outcome. Worked feedback explains what changes when the task, recipient, policy or available evidence changes.
Offline Python exercises model grants, proposed changes and execution state with synthetic data. They do not execute repository code, contact a provider or claim to implement a production sandbox. Each exercise states the boundary it tests and the additional evidence a deployed system would need.
Start with the two open lessons to build the task and delegation map. The workspace lesson is available after sign-in. The remaining lessons develop the execution ledger, memory publication rule, recovery plan, evaluation and final release project. The review packet is the outcome; memorizing terms is not the assessment.
When you finish, you can
- Translate an engineering request into a current task grant and explicit data audiences
- Constrain delegated work without confusing worker identity with permission
- Review a proposed patch separately from filesystem and code-execution isolation
- Bind approved terms, shared reservations and retries to a single intended effect
- Publish reusable findings with evidence, audience policy and a versioned lifecycle
- Stop and resume parent and child work without reviving revoked authority or resetting budgets
- Evaluate useful completion, forbidden effects and unknown outcomes with clear denominators
- Defend a release memo from a fixed packet of incomplete evidence
BEFORE YOU START · You can read basic Python and follow an API request across services. Complete Security Fundamentals if process isolation, identity or network boundaries are unfamiliar. The exercises use synthetic in-memory state and require no cloud account, agent framework or payment service.
Syllabus
Define and delegate the task
Record current authority, intended data audiences and worker relationships before choosing the tools that can carry out the maintenance request.
Review changes and control their effects
Separate untrusted workspace processing from a proposed patch, then model approval, shared reservations and uncertain publication outcomes.
Govern memory and interrupted work
Publish findings under an evidence and audience policy, and stop or resume work without losing revocation, budget or operation state.
Evaluate the workflow and defend the release
Combine policy tests, useful-task outcomes and uncertainty into a fixed evidence packet, then write a release decision with enforceable limits.