Diagnose, plan, implement and review with context.
Portfolio case study
Agentic SRE
Turn operational signals into reviewed, approved and measured engineering outcomes.
Agentic SRE is an independent AI and platform engineering project that connects observability, structured work, coding agents, deterministic validation, specialist reviews and human approval into one auditable delivery loop.
The system graph below shows the full control loop: runtime signals, scoped tool access, coding agents, CI quality gates, human approval and feedback into a managed multi-service runtime.
Faster triageSignals become scoped engineering work instead of disconnected toil.
Auditable deliveryIssue, plan, PR, checks and approval stay linked.
Human-owned riskAgents assist, but high-impact decisions remain governed.
Public-safe note: examples are sanitized and representative. Workflow views use conceptual states, not private production metrics or internal infrastructure details.
Issues, CI, policy gates and audit trail bound the work.
High-impact changes remain accountable and reviewable.
Technical deep dive
A governed AI delivery graph, not a disconnected set of tools.
The graph shows how triggers, orchestration, scoped tools, coding agents, CI gates, human approval and runtime feedback connect into one auditable control loop.
Triggers
Orchestration
MCP boundary
Context / agents
Delivery
Feedback
Event remediation pathMobile-safe view of the selected graph route.
- 1Observability signalSignal starts triage, not an automatic change.
- 2Orchestration runtimeNormalizes work and creates run context.
- 3MCP scoped accessConstrains tool access through explicit boundaries.
- 4Specialized agentsPlan, implement or review within the governed loop.
- 5Pull requestChange becomes reviewable code and evidence.
- 6CI Control PlaneDeterministic checks bound probabilistic output.
- 7Human approvalHuman owns risk and merge decision.
- 8Runtime feedbackObservability closes the loop after change.
- 1Cron / schedulerScheduled audit starts proactive improvement.
- 5Structured issueFinding becomes scoped backlog.
- 1LiteLLM routerRoutes model calls through profiles and status.
- 2Provider fallback chainFallback is visible and public-safe.
- 3Specialized agentsAgent work continues after routing decision.
Trigger · Observability
Observability signal
A monitored signal from the documented observability stack and reporting workflows.
SRE reporting flows use observability surfaces and read-only tools. The signal starts analysis; it does not automatically authorize production changes.
It ties remediation to measurable system behavior in the managed runtime.
Operating layers
The deeper machinery behind the graph.
Click a layer to expand a human-readable explanation. Runtime scale is shown as a first-class layer, while service details remain public-safe.
Selected layer explained
Scale · Managed operations
Runtime Scale
The Agentic SRE loop maintains and monitors roughly 70 services or containers across the managed runtime.
The public view groups the runtime into ingress, observability, automation, AI stack, smart-home/runtime apps, storage, backup and developer tooling instead of exposing private service internals.
The scale makes the portfolio story concrete: this is not a toy PR bot, but an operating model for a real multi-service platform.
Repository stack overview · service docs · compose and runtime docs
Project at a glance
A compact reference for the full case study.
The operational gap
Monitoring detects symptoms. It does not automatically create a safe path to resolution.
The hard problem is the manual handoff between alert, context, owner, change, review, deployment and proof that the service actually improved.
Alert
Investigate manually
Search docs
Find owner
Implement
Test
Deploy
Verify
Context switching, tribal knowledge, inconsistent quality and slow feedback loops.
Main story
Signal → verified change
One work item evolves from operational signal into a reviewed, approved and measured engineering outcome.
Representative example
A recurring integration error becomes one governed remediation loop.
The platform correlates telemetry and repository context, creates a structured issue, prepares a change, runs validation and review, then checks whether service indicators move back toward target.
- Signal
Alerts, metrics, logs, traces and scheduled checks.
- Evidence
Telemetry, repository context and runbook hints are correlated.
- Structured Issue
Ambiguous signal becomes scoped work with constraints.
- Agent Plan
Remediation plan and verification path are proposed.
- Pull Request
Change is prepared as reviewable code and evidence.
- CI
Static checks, tests and policy gates run deterministically.
- AI Review
Specialist reviewers critique technical, business and risk impact.
- Human Approval
Engineer reviews evidence and owns the decision.
- SLO Verified
Observability confirms whether the outcome improved.
Probabilistic intelligence
Agents propose the best next actions.
- Diagnoseunderstand what is happening
- Planpropose safe and effective steps
- Implementgenerate code and configuration changes
- Reviewcritique quality, risks and tests
Deterministic platform rails
Guardrails make every change reviewable.
- Issue contractsstructured scope and acceptance criteria
- Testsautomated verification before merge
- Policy gatessecurity, compliance and quality checks
- Audit trailissue, PR, commit and review history
- Observabilitymeasure impact and close the loop
Narrative frame
Engineering 3.0 in practice
Not vibe coding. Intent, architecture, constraints, validation and governance move to the center.
Traditional workflow
Fragmented. Manual. Error-prone.
AlertInvestigateSearch docsFind ownerImplementTestDeploy
The engineer spends energy moving information between disconnected systems.
Engineering 3.0 workflow
Structured. Governed. Outcome-driven.
- Define intentclear outcome and constraints
- Structured issuecontext, scope and guardrails
- Agents plan and implementspecialized agents collaborate
- Deterministic validationtests, policies and runtime checks
- Human approvalengineer remains accountable
- SLO feedbackmeasure, learn and improve
Architecture by responsibility
The Agentic SRE platform loop
Telemetry, logs, metrics, scheduled checks and user feedback.
Runtime, dispatcher, worker roles, task state and handoff.
Issues, branches, PRs, evidence and reviewable changes.
Right agent, right tool, right context and provider fallback.
CI, policies, specialist reviews and human approval.
SLI/SLO feedback, DORA signals, dashboards and auditability.
Representative workflow view
Agentic Delivery Control Plane
Compact public-safe view of the governed delivery model. Values below are representative workflow states, not production metrics.
1 Backlog & Issues
Improve recurring integration error triageP1 · structured issue · owner required
Document deployment verification loopP2 · docs · DocGuard
Reduce flaky review rerunsP2 · CI · router evidence
2 Agent execution
Code AgentRUNpreparing PR
Test AgentRUNexpanding checks
DocGuardREUSEdocs unchanged
Risk ReviewerRUNchallenging assumptions
Visual ReviewSKIPno image delta
3 Quality gates
- Lint & static analysis PASS
- Unit / script checks PASS
- Policy validation PASS
- Review thread gate PENDING
- Human approval REQUIRED
4 Reliability signals
SLO statuswithin targetError budgethealthyPost-change checkpending verification
Reviewer routing matrix
| Change type | Technical | Business | Risk | DocGuard | Visual |
|---|---|---|---|---|---|
| Code | RUN | RUN | RUN | SKIP | SKIP |
| Docs | REUSE | REUSE | REUSE | RUN | SKIP |
| Workflow | RUN | RUN | RUN | RUN | SKIP |
| Diagram | SKIP | SKIP | SKIP | RUN | RUN |
Representative example. Exact routing is implementation-specific and can evolve over time.
Provider fallback chain
PrimaryFallback 1Fallback 2Fallback 3Break-glass
Only reviewers selected to run call an LLM. Model/provider fallback is separate from reviewer routing.
Capabilities demonstrated
From exploratory AI platform to reusable delivery pattern.
The value is a repeatable operating model for turning uncertain AI output into governed engineering work that stakeholders can trust, inspect and improve.
Frame the operational pain, users, constraints and success signals before choosing models or tools.
Split responsibilities across agents, deterministic rails, integrations, observability and governance.
Use issues, branches, PRs, tests and specialist reviews to make agent output auditable and reversible.
Keep approval, escalation and destructive-action boundaries explicit instead of assuming full autonomy.
Make the workflow reusable across services, providers and agent roles rather than building a one-off demo.
Close the loop with SLI/SLO feedback, review evidence and follow-up work when the result is not good enough.
A controlled AI engineering platform: small enough to inspect end-to-end, structured around concerns that matter in production-grade AI solution architecture.