GitariusAF is a conceptual and operational framework for building AI-driven and human-assisted systems through composable, verifiable capabilities. It defines how to decompose complex work into small units, orchestrate them across humans and automation, and continuously evaluate when and how to automate.
GitariusAF is not a platform or a product. It is a set of principles for designing systems where automation is introduced incrementally, based on evidence, within a composable architecture of verifiable capabilities.
Complex systems are decomposed into small, independent capabilities. Each capability is verifiable, replaceable, independently implementable, and composable into workflows. Monoliths are a failure mode.
Each capability can be carried out as human work, AI automation, a software script, or a hybrid of the three. The framework defines the capability — it does not prescribe how it is fulfilled.
Manual execution is not a failure state. It is a valid and often optimal implementation choice. Systems evolve gradually from manual to assisted to automated as evidence justifies each transition.
Automation is not ideological. Each capability is evaluated on effort to automate, operational value, risk reduction, maintainability, and speed. Only automate when it produces measurable value.
Open-source repositories demonstrate the framework in practice. They are starting points, not mandates. The framework can be implemented differently — these repos validate that the model works in real systems.
A capability is the atomic unit of the framework. It represents one discrete, verifiable piece of work — small enough to be independently owned, validated, and replaced without affecting the rest of the system.
Capabilities are defined by what they do and what they produce, not by who or what executes them. This separation allows the same capability definition to be fulfilled by a human today and by an automated agent tomorrow — with no changes to the capability's interface or the workflows that depend on it.
Complex workflows are assembled from validated capabilities. Orchestration happens at the composition layer, not inside individual units. This means errors are isolated, components are reusable, and the system can evolve without full rewrites.
Each capability defines its success criteria and failure conditions explicitly. Validation is built-in, not bolted on.
Any capability can be re-implemented — by a different executor, technology, or approach — without breaking dependent workflows.
Capabilities combine into higher-order workflows through well-defined interfaces. Simple units assemble into complex systems.
GitariusAF is explicitly AI-driven. AI agents are not an optional add-on — they are a primary execution mode alongside humans and scripts. Each type has a distinct role, and capabilities are designed from the start to be fulfilled by any of them.
Humans handle capabilities that require judgment, context, or relationship — things where ambiguity is high and the cost of a wrong automated decision exceeds the cost of human time. Human execution also serves as the baseline measurement before any automation decision is made.
AI agents handle capabilities that are too complex for deterministic scripts but too high-volume for humans. They reason over unstructured data, synthesize across sources, apply judgment at scale, and operate within the same verifiable capability contracts as any other executor. AI is not a replacement for humans — it is a different kind of executor with different tradeoffs.
Deterministic scripts and software handle capabilities where inputs and outputs are fully known, logic is stable, and performance matters. These are the fastest, most predictable executors — but they require complete specification upfront and break when inputs change unexpectedly.
GitariusAF treats humans as a permanent, valid part of the execution model — not as a transitional placeholder until AI can take over. Systems evolve through three stages based on evidence, not ideology.
A human carries out the capability directly. This is the default starting point. It is efficient, low-risk, and produces real data about the effort and complexity involved. Not a failure — a measurement.
AI or tooling assists the human without replacing them. Drafts, suggestions, or pre-processing reduce effort. The human retains decision authority. Automation is introduced at the edges of the workflow.
The capability runs end-to-end without human involvement. Reached only when Stage 1 and 2 data justifies the investment. The capability interface does not change — only the executor does.
Automation is an investment, not a default. Before automating any capability, evaluate it across five dimensions. The decision should be traceable and revisable as conditions change.
How complex is the implementation? Does the engineering effort justify the operational savings? Low-effort automations with high execution frequency are the best candidates.
How much does this capability run? How critical is it to the workflow? High-frequency, high-impact capabilities have stronger automation ROI than infrequent or niche tasks.
Does automation reduce error rates, inconsistency, or manual mistakes? Some capabilities produce better outcomes when automated precisely because humans are inconsistent at high volume.
Will the automation require constant updates as inputs and conditions change? High-volatility capabilities may be cheaper to keep manual than to continuously re-automate.
Does automation unlock a throughput or latency benefit that manual execution cannot match? Speed gains matter when the capability is on the critical path of a larger workflow.
These repositories demonstrate how GitariusAF principles work in a real system. They are not the only way to implement the framework — they exist to show feasibility, provide a starting point, and validate the model in practice.
These repos are reference implementations, not mandatory components. You can adopt the framework's principles and build your own implementation stack. The concepts are what matter — the code is an example.
Reference implementation of the framework's control plane. Contains the storage registry, schemas, data dictionary, task catalog, and governance scripts. Demonstrates how to build a Unified Source of Truth that all capabilities can reference.
Reference Implementation · Read-Only at runtimeReference implementation of the capability execution environment. Shows the Test/Production boundary, manifest-driven access control, shared library versioning, and the 3-phase capability lifecycle from draft to deployed.
Reference ImplementationA Claude Code plugin packaging 10 GAF methodology skills — from capability bootstrapping and schema validation to pre-deploy readiness checks and workflow orchestration. Demonstrates how framework methodology can be encoded as reusable AI skills.
10 Skills · Installable