Autonomous PLATE Engine & Scheduled Procedures

Autonomous PLATE Engine & Scheduled Procedures

This is the heart of the PLATE vision.

PLATE should operate at the user's budgeted token rate and run for a very long time with minimal human touch. The core is software (an AutonomyEngine in plate_core) that introspects project state (health, Goals gaps, epics, fragments, costs, procedures due) and delegates to agents (or executes deterministic safe steps), all governed by a single risk tolerance knob and real budget enforcement.

Created via full interactive TUI Q&A planning (two rounds of structured questions + consensus) per the PLATE process and AGENTS.md. Design artifact committed in the same session: docs/design/autonomous-plate-engine.md.

Vision (synthesized from planning)

• User configures autonomy.risk_tolerance (low / medium / high) and token_budget (daily/per-cycle) in .plate.
• High tolerance + budget headroom → the repository largely drives itself: appropriate PRs auto-merge, scheduled procedures (nightly drift detection + info audit + feedback integration + cost rollup + cleanups + release readiness, etc.) execute unattended, gaps are turned into well-formed Questions or child stubs, all with complete GitHub-auditable markers, usage reports, and quiet terminal output.
• A new first-class AutonomyEngine (new module + MCP surface + gh plate autonomy run --loop) is the software orchestrator. It builds directly on (and makes executable) the existing state-machine catalog, what_next, ContemplationEngine, information audit, babysit, costs, health, and delegation surfaces.
• Data-driven procedures live in .agentic/procedures/<id>.json (cadence, risk_level, steps as allow-listed MCP/tool calls, log_to, max_tokens). Engine tick_schedules runs only those permitted by current tolerance.
• Full governor: before any costly action the engine checks budget (throttle → force dry_run/skip low-pri/sleep; pause → stop with resume instructions; always observable).
• Prioritized user-love features (from planning): (1) visible budget governor + burn, (2) single risk knob for low-touch experience, (3) formal recurring procedures that feel magical, (5) autopilot_score / observability % (cycles run, PRs auto-merged, gaps closed autonomously).

Risk Tolerance Matrix (adopted exactly)

• off / absent: no new auto behavior (existing AUTONOMOUS_MODE + risk:low path remains 100% compatible).
• low: auto-merge risk:low PRs (with all current guards), safe babysit suggestions only, audits dry_run by default, explicit-only planning.
• medium: + risk:medium PRs, medium-safe auto-apply + thread resolution, apply-mode for medium procedures/audits.
• high: + risk:high PRs (critical never), auto-stub generation in plan_epic from Goals+audit (stubs get need:refinement), scheduled procedures up to high run in apply, broader safe delegation. Budget governor still protects spend.

Critical-risk items, changes to AGENTS.md/SPEC/credentials/workflows, or anything carrying need:human-review are always human-only (Task + explicit review). This matrix + the existing risk:* labels + AUTONOMOUS_MODE file is the complete, reviewable control surface.

Core Engine Shape (new first-class AutonomyEngine)

plate_core/autonomy.py (orchestrator) + AutonomyStatus, ProjectSnapshot, CycleReport, ProcedureDef.

Key methods (refined in the design doc):

• introspect() → rich snapshot from health + epics + goals + fragments + costs + due procedures.
• enforce_budget(estimated, action) → throttle/pause decision before heavy work.
• decide_next(snapshot) → list of Actions (what_next + risk-filtered + budget-aware + procedures due).
• run_cycle(dry_run=False) → the main loop step: introspect → enforce → decide → execute (deterministic via core or delegate via plate_delegate_to_agent + trigger comments) → log PLATE-AUTONOMY-CYCLE / PLATE-PROCEDURE-RUN + usage → report.
• run_procedure(id), tick_schedules(), get_status() (includes autopilot_score).

Exposed as MCP tools (plate_autonomy_status, plate_autonomy_run_cycle, plate_autonomy_list_procedures, plate_autonomy_run_procedure) and CLI (gh plate autonomy status|run|loop --max-cycles N --dry-run).

--loop mode is the persistent driver hosts (Grok TUI scheduler_create, /loop, Copilot equivalents, GitHub scheduled workflows) call. It emits only terse one-sentence bullets per quiet_operations rules.

Procedures

Data-driven in .agentic/procedures/. Schema includes id, cadence (named or cron), risk_level, description, steps (allow-listed tool + args + apply_if_risk_ok), log_to, max_tokens_per_run, enabled, requires, etc.

MVP built-ins (executed only when tolerance allows): nightly-drift-detection, nightly-info-audit (or delta), feedback-integration (babysit-all for configured agents), cost-rollup, release-readiness-scan, stale-branch-cleanup, goals-refresh, binary-hygiene-audit, contemplation-backlog-sweep.

Every execution produces traceable markers and usage blocks. Engine dispatch is allow-list only + risk gated.

Scope In (MVP slices for atomic PRs)

• .plate autonomy schema + validation + health/config surfaces + migration
• AutonomyEngine implementation + budget governor + ProjectSnapshot / reports
• New MCP tools + gh plate autonomy CLI (including --loop host integration points)
• Generalization of auto-merge workflow + pr_babysit.py to honor risk_tolerance (while keeping all guards)
• Full plate_plan_epic (replace stub) with risk-aware auto-stub generation at high tolerance
• Procedures registry + 4-5+ built-ins + execution + logging to .agentic/autonomy/ or Discussions
• Observability: autopilot_score, burn rate in status/health, procedure run history
• Persona / agent_guidance / baseline catalog updates for autonomy loops
• This design doc + AGENTS.md + wiki/Goals notes + template payload + fragments
• Unit + simulated long-running e2e tests under budget

Stretch / follow-up children: release ceremony autonomous prep, extension contrib of procedures, deeper cost estimation models, webhook-driven orchestration, dedicated Maintenance issue type.

Scope Out (for this Epic or explicit non-goals)

• Replacing GitHub as source of truth
• New external hosted engine services
• Weakening any human checkpoint or Task contract
• Removing the existing risk:* labels or AUTONOMOUS_MODE compatibility
• Perfect predictive cost estimation (best-effort + observable is the bar)

Child Stubs (created in same planning session)

See the design doc for the full proposed breakdown and rationale. High-level (order for atomic PRs favors budget/risk/procedures/score first):

1. Research: Budget governor models & throttle strategies (integrate with costs.py, estimation heuristics)
2. Design: AutonomyEngine contract, data models (Snapshot/Report/Procedure/Action), decision rules, procedure schema
3. Feature: .plate autonomy section + plate_config + report in health/config surfaces
4. Feature: plate_autonomy_* MCP tools + AutonomyEngine skeleton + governor
5. Feature: gh plate autonomy status/run/loop CLI + --loop integration for host schedulers (TUI scheduler_*, /loop, etc.)
6. Feature: Generalize auto-merge + babysit to .plate risk_tolerance (workflows, pr_babysit, docs)
7. Feature: Full plate_plan_epic (replace stub) + risk-aware auto-stub gen from Goals+audit at high tolerance
8. Feature: Built-in procedures registry + initial procedures (drift, audit, feedback/babysit-all, cost, cleanup, ...) + safe dispatch + logging
9. Feature: Autonomy observability (autopilot_score, burn in health/status, .agentic/autonomy/ run logs, wiki surface)
10. Feature: plate persona, agent_guidance (quiet + autonomy), baseline catalog updates
11. Documentation: this design doc (already committed), AGENTS.md updates, template payload, fragments
12. Tests: engine/config/procedure units + budget-constrained long-run e2e

All children created as stubs carrying need:refinement (and appropriate type label). They will be refined and implemented in follow-up atomic PRs targeting the correct release track (per gh plate release status at PR time).

Acceptance Criteria (high-level; see design doc + child ACs for detail)

• A user can set risk_tolerance + budget in .plate, enable schedules, and have the engine run multi-hour cycles (via host scheduler + gh plate autonomy run --loop) that respect the budget, run permitted procedures, advance safe work, and produce only terse output + durable GitHub artifacts.
• Risk matrix behaves exactly as specified; critical/AGENTS-touching work is never auto-executed.
• New procedures are declaratively defined, risk-gated, and produce PLATE-PROCEDURE-RUN markers + usage.
• plate_autonomy_status + health show budget remaining, autopilot_score, due procedures, and human checkpoints.
• Existing repos using only AUTONOMOUS_MODE + risk:low see zero behavior change.
• All changes follow PLATE (atomic PRs ≤ ~10 files preferred, fragments, tests alongside, clean human titles, Closes in body only, etc.).
• This Epic's own planning dogfooded the process (design doc + fragment + GitHub Epic + child stubs created interactively).

How to work on this Epic

1. Read docs/design/autonomous-plate-engine.md in full.
2. Pick a child stub (start with budget/risk/procedures/score slices per planning priority).
3. Follow the Feature/Bug/Research/Design work loop in AGENTS.md (tests, fragments where process-changing, gh plate release status for base branch, clean PR title, labels + Closes #E in body).
4. Use the new autonomy surfaces on this repo itself where the tolerance permits (dogfood).
5. Human checkpoints remain sacred.

Planning session complete. Design doc + fragment committed locally. GitHub Epic and child stubs created in the same agent session. Next human step: review the Epic, refine/assign children, set milestone / release track linkage, and begin implementation slices.

Interactive planning performed with full Q&A consensus on title, risk model, engine shape, procedures, budget governor, prioritized love features, and creation flow.
See docs/design/autonomous-plate-engine.md for the complete record.

Read docs/design/autonomous-plate-engine.md and the relevant child stub before choosing a slice; AGENTS.md defines the required work loop. Start from the named entry points for that slice, such as plate_core/autonomy.py, .plate configuration, MCP tools, or the gh plate autonomy CLI. Done means one atomic child scope meets its stated acceptance criteria with accompanying tests and required documentation or fragments.