I have been working on this Agentic Framework for some time now, and I want to share where the Claude Agentic Framework stands today. It is a configuration layer that sits on top of Claude Code CLI and turns a single chat session into a disciplined team of 21 specialized agents. The agents do the work. Hooks enforce the quality. A consistency system keeps everything honest. Recent changes made the reviews much stronger and finally gave us a proper self-scoring loop for non-code work.
This is not another prompt collection. It is real enforcement.
From Chatbot to Agent
Most people still treat Claude like a chatbot. You ask a question, you get an answer, then you copy the code, run it, fix the errors yourself, and ask again. The model never sees the result of its own work.
An agent works differently. You give it a goal. It plans, edits files, runs commands, reads the output, and keeps going until the outcome is finished or it hits a real decision point. Context is gathered by the agent itself. Memory lives in CLAUDE.md and memory files. Tools are full — filesystem, shell, git, MCP servers. Feedback loops exist. Guardrails are hard.
The difference shows most clearly in context economics. A single long session fills the window with every file and log until early decisions fall out of memory. In the agentic setup the orchestrator stays lean. Heavy reading happens in disposable child windows that return only short summaries. During the last overhaul of this repository itself, the two review agents alone burned around 357k tokens inside their own windows. The coordinating session received two reports of roughly 1,500 tokens each.
Architecture in Practice
Everything starts from one objective. Routing (driven by CLAUDE.md rules, the /delegate command, and agent descriptions) sends the work to the right specialist. Skills and MCP servers support that specialist. When the specialist finishes, the code-review-gatekeeper looks at quality. Findings get fixed. Then the peer-review-critic runs an independent final review with a deliberately read-only toolset. A stop gate checks that a real review was recorded. Only then can the session end.
The framework recently went through its own pipeline. A multi-agent audit found the gaps, ten commits fixed them, both review agents signed off, three CI jobs passed, and the stop gate enforced the final review live.
Stronger Reviews That Actually Block
The biggest recent change is the verdict-aware peer-review stop gate. Before, the system only checked whether a review had happened. Now the peer-review-critic must emit a clear VERDICT: APPROVED or VERDICT: CHANGES_REQUIRED line. Recorder hooks log the decision. The stop gate refuses to let the session end if the verdict is not APPROVED. There is no quiet bypass.
New and improved commands support this:
- /build runs an autonomous loop that builds exactly what the spec says and iterates with the spec-compliance-reviewer until it receives APPROVED (max three iterations).
- /review-spec performs a manual conformance check.
- /delegate now consumes specifications more cleanly and avoids earlier per-todo deadlocks.
The enforcement finally feels mature. It is no longer “was there a review?” It is “what was the actual verdict and did the system respect it?”
Self-Scoring Loop for Specs, Plans and Documents
Code already has the review gates. Everything else — specifications, architecture notes, project plans, proposals — used to rely on vague “make this better” instructions. The new self-scoring-loop skill changes that.
The loop is simple and strict:
- Write a rubric first (5–7 weighted criteria that sum to 100). The rubric stays fixed for the whole loop.
- Score the current version 0–100 against each criterion with a short justification.
- Name the one or two weakest criteria and explain exactly why points were lost.
- Rewrite only the weak parts. Keep what already scored well.
- Rescore. Stop if the score improves by less than 3 points, reaches 90+, or hits three iterations.
- Return the polished version together with the final scores and the trajectory (for example 68 → 81 → 87).
Guardrails are deliberate. No mid-loop rubric changes. Scoring without a visible rubric is invalid. The skill is advisory and never replaces the peer-review gates for code.
I use this myself before I present any non-code deliverable. The improvement is measurable and the stopping rules prevent endless churn.
Related Discipline in vouchfx
The same mindset shows up in my other project, vouchfx. There the “delegate runs” idea appears in a different form: declarative .e2e.yaml specs are compiled once into memory-safe C# delegates via Roslyn. Those delegates then execute against a full container topology orchestrated by .NET Aspire and Testcontainers. Verdicts are explicit (Pass, Fail, EnvironmentError, Inconclusive) and map cleanly into CI exit codes and reports. The self-scoring idea from the agentic framework and the strict delegate-based execution in vouchfx come from the same place — quality must be measurable and enforced, not hoped for.
Numbers and Getting Started
Today the framework ships with:
- 21 specialized agents across seven categories and three model tiers
- 4 registered hooks (one hard blocking gate)
- Several operational skills including the self-scoring-loop
- 5 MCP servers
- A consistency validator that derives truth at runtime and fails the build on any drift 3 CI jobs that include a Windows leg
Installation is straightforward:
git clone https://github.com/tomas-rampas/claude-agentic-framework ~/.claude
pwsh -NoProfile -File ~/.claude/scripts/install.ps1
bash ~/.claude/scripts/validate-consistency.sh # expect RESULT: PASS
You need Claude Code CLI, PowerShell 7+, bash, jq, and the usual Node/uv pieces for the MCP servers.
Closing
I built this because I was tired of agents that sound confident and then quietly skip the hard parts. The combination of real stop gates, verdict recording, and a structured self-scoring loop for everything that has no test suite makes the system feel much closer to a real engineering team.
The framework is open. The presentation that started this write-up lives in the repository under docs/team-presentation.md. The Medium post that covered the review and scoring changes is already public. Feedback, issues, and better rubrics are welcome.
Agents write the code. Hooks make quality non-negotiable. The consistency system keeps the whole thing honest. That is the current state, and I plan to keep tightening it.
Top comments (0)