CCDV-P · Agent Fleet Operations for Software Delivery
Agents with nobody watching, goals, schedules and event response
The continuous-integration pipeline fails at three in the morning. An agent triggers itself, reads the log, finds that a test depends on a date, fixes it and opens a pull request. When the team arrives, the PR is ready. Another night, the same agent misread an infrastructure error and opened twelve PRs “fixing” a problem that didn’t exist. Unattended operation carries a lot of value and a lot of risk, and what makes it safe is the design around the agent.
Three ways to run without a person
- Goal-driven: you give it a goal with a definition of done (“make the suite pass on branch X”, “migrate this module”) and the agent iterates until it gets there or hits a limit.
- On a schedule: periodic tasks (check vulnerable dependencies nightly, triage new issues, update stale documentation).
- Event-driven responder: triggered by an event: a CI failure, a new issue, an alert, an opened PR. The typical case is first response to a CI/CD incident: it diagnoses and proposes, it doesn’t resolve in production.
Claude Code runs without an interactive interface via claude -p (headless mode, with text, JSON or streaming JSON output) and integrates with CI systems such as GitHub Actions; the Agent SDK is for building your own. Check the current options in the documentation.
What makes an unattended run safe
Since nobody is watching, the limits have to be in the design:
- Minimal scope and permissions: a first-response agent may read logs and open a PR, not deploy or touch production. Explicit pre-approved permissions (an allowed-tools list), never “bypass all permissions” in an environment with real access. If broad autonomy is needed, in an isolated environment.
- Budget and cap: a maximum of turns, cost and time per run, and a limit on runs per event to prevent loops (an agent opens a PR that triggers CI that triggers the agent).
- Idempotency and deduplication: the same event doesn’t open two PRs; work already done is recognized.
- Checkpoints and state: on long tasks, save progress to resume without repeating (see the durable execution lesson).
- Branch and review: changes go to a branch or PR, never straight to the main branch; a person reviews before merging.
- Complete logging: what triggered it, what it saw, what it did and why, so it can be audited the next morning.
Notification and escalation
An unattended agent must know when to stop and ask for help. Escalation is defined in advance: conditions to halt (the failure isn’t code but infrastructure, the task touches something out of scope, the budget ran out, several attempts failed), whom it notifies (the on-call person, a channel), with what information (what it tried, what it found, what it proposes) and how (a notification that gets seen, not a buried log). Silence when everything goes well, noise when a decision is needed: if the agent notifies everything, nobody reads; if it notifies nothing, nobody learns what failed.
The usual traps
- A first-response agent with permission to deploy or write to the main branch.
- No cap on runs: event loops triggering each other.
- “Bypass permissions” so it doesn’t stall, in an environment with real access.
- Retrying again and again without escalating.
- Changes merged with no human review because “the on-call agent did it”.
On the exam
If asked for an agent to respond to CI failures, the safe answer diagnoses and proposes on a branch or PR, with minimal scope, budget and run caps, and escalation to a person. Discard “give it full permissions so it resolves on its own” and “always notify every step”.
Quick question
A practice exam question on this domain. It counts towards your progress.
A company with 600 developers is rolling out Claude Code. Security requires that only an approved set of MCP servers can be used, that certain commands remain denied everywhere, and that usage telemetry is collected centrally. Today the approved list lives in a wiki page and in each repository's .claude/settings.json, and developers can edit their own local settings.
An audit found laptops with unapproved MCP servers connected to internal systems, even though the wiki says they are not allowed. The security team also wants the same rules to apply to contractors who use their own laptops.
Which approach enforces the policy for all developers?