Intent · Architecture · Agentic SDLC
The Plan Was Accurate.
It Was Still Wrong.
The plan was coherent. The technology was valid. The missing architectural decision changed everything.
Flagship project / Agentic SDLC
Tinkerworks.
Agents do the work.
The pipeline holds the control.
My implementation of governed agentic software delivery. Local models work inside explicit task contracts, independent validation, and human approval boundaries.
The governed workflow
Every handoff has a contract.
- 01Human
Define
Set the outcome and constraints.
- 02Architect
Design
Propose the approach and its decisions.
- G1Human gate
Approve
Review the design and intended scope.
- 03Dev Lead
Plan
Break work into explicit contracts.
- 04Developer
Build
Implement and open a pull request.
- 05Validator
Verify
Check the claimed repository state.
- G2Human gate
Merge
Review the completed feature.
This is the delivery model. Human review also applies to task pull requests. Automation of post-merge handoffs and a consolidated controller are part of the ongoing architecture work.
The contract table
Make the boundaries explicit.
A useful agent needs a clear assignment and a clear limit to its authority.
| Role | Produces | Boundary |
|---|---|---|
| Architect | Design and decision records | States constraints and assumptions for human review. |
| Dev Lead | Ordered subtasks and contracts | Plans against the approved design and environment facts. |
| Developer | Changes on a branch and a pull request | Works within the task contract; hands off for review. |
| Validator | A verdict against repository evidence | Checks through an independent read-only credential. |
| Coordinator | Findings and a delivery briefing | Surfaces blockers and work needing human attention. |
| Human | Intent, approval, and merge decisions | Owns the architectural and product choices. |
The vocabulary
Anatomy of a governed agent.
The model is the smallest part. Most of the engineering is what surrounds it.
Harness
The runtime around the model: the loop, the tools it can call, the identity it acts as, and when it must stop.
Agent
A role running in the harness with one job and one boundary. Architect, Dev Lead, Developer, Validator, Coordinator.
Skill
A packaged, versioned procedure an agent loads for a task. Procedure lives in skills, not in ever-growing prompts.
Contract
The written expectation for a task: inputs, outputs, constraints, and the evidence that will count as done.
Gate
A point where a human decides. Design approval and merge are gates; nothing automated passes through them.
Evidence
Observable repository state: branches, pull requests, files, labels. The only thing that moves work forward.
The central idea
“An agent’s output is a claim.
System state is evidence.”
Verify what exists.
The validator checks branches, pull requests, changed files, labels, and audit evidence. A completion report alone cannot make a run succeed.
Expose the assumptions.
A technically sound plan can still miss the intended architecture. Contracts need explicit constraints, and intent needs human review.
Make authority concrete.
Scoped identities and repository rules turn approval boundaries into controls. The Developer identity is implemented; rollout across roles continues.
The foundation / Stormforge
A real lab.
Real constraints.
Stormforge is the multi-node GPU fleet beneath Tinkerworks. It gives me a place to run local inference, operate the surrounding infrastructure, and test what happens beyond a single successful demo.
How the lab is built- Inference
- Local models behind one gateway, routed by capability.
- Infrastructure
- Kubernetes and GitOps delivery.
- Memory
- Decisions and contracts recorded in Git.
- Feedback
- Observed failures become the next controls.
The evidence behind the design
Start with what went wrong.
The Plan Was Accurate.
Evidence · Execution · August 2026
The Agent Reported a Pull Request
That Never Existed
An agent reported success. The repository told a different story. The case for independent verification.