A/A/A x 4D, productised
Services that map to a framework, not a pitch deck
Anthropic teaches three modes of working with AI — Automation, Augmentation, Agency — across four competencies: Delegation, Description, Discernment, Diligence. Every service below is anchored to a specific square on that grid. So is the work.
Most AI projects fail because the buyer is sold Agency when they were ready only for Automation. We watched it happen often enough to rebuild our offer around Anthropic’s own framework.
Three modes. Automation — AI executes a defined task on your instruction. Augmentation — you and AI think together, turn-by-turn. Agency — you set policy and the AI operates on its own under those policies.
Four competencies. Delegation (what to give the AI), Description (how to brief it), Discernment (how to evaluate what comes back), Diligence (how to take responsibility for it).
Every service below is anchored to a mode and to one or two competencies. We tell you which on the first page of the proposal. The framework is Anthropic’s, used here under fair attribution to Dakan, Feller, and Anthropic (CC BY-NC-SA 4.0). The productisation is ours.
Claude Code & AI Development
Where this usually goes wrong
Most engineering teams have already tried a coding assistant. Velocity went up for two weeks, then plateaued, because the assistant doesn't share your context and nobody's measuring whether the code it produces is actually better. The work is augmentation in name only — your engineers stay in the loop on every keystroke instead of every meaningful decision.
How we work it
This is Augmentation done properly: human and AI working turn-by-turn on a shared problem, with explicit Description (what we want, how, in what voice) and explicit Discernment (does this output deserve to ship). Claude Code is the surface; your team is the partner.
- Skills + plugins for your codebase — your patterns, your tests, your review checklist, encoded so Claude obeys them by default instead of being re-prompted on every PR.
- Hooks wired to your CI — lint, type-check, security scan run before any AI-generated change merges. Diligence at the merge gate, not in a meeting.
- Agent Teams for cross-layer work — frontend, backend, and tests changed in parallel by separate Claude instances coordinating through a lead.
- Description + Discernment training for your engineers — how to brief Claude so the first answer is usable, and how to tell when it isn't.
20-60% productivity improvement
Measured against your team's pre-engagement velocity, not industry averages
MCP System Integration
Where this usually goes wrong
You have a CRM, a doc store, three databases, and a queue, and every AI experiment so far has been a brittle screenshot-and-paste demo. The fix isn't another bespoke connector. The fix is to decide which tasks should be Automation — scripted, repeatable, run by AI on your data — and to wire the data correctly once.
How we work it
This is Delegation work: deciding what is best handled by Automation rather than left to humans or shoved into ad-hoc augmentation. MCP is the protocol Claude uses to act on your systems — under Linux Foundation governance, 97M+ monthly SDK downloads, MCP v2 beta.3 multi-agent comms.
- Custom MCP servers over your CRM, ERP, databases, document stores. Authenticated, rate-limited, audit-logged from day one.
- Task-by-task delegation map — for each workflow, we tell you what should be Automation, what stays Augmentation, and what is not safe to delegate yet.
- One protocol, not a connector zoo — kill the integration tax so the next AI capability is a configuration change, not a project.
80% reduction in integration time
Versus the bespoke point-to-point integrations you'd otherwise commission
Autonomous Agent Development
Where this usually goes wrong
Most AI projects fail because the buyer is sold Agency before they're ready for it. Agency means the AI operates on its own under policies you set — that demands governance, not just a slick demo. Standing up an agent without the diligence layer is how regulators end up reading your audit logs.
How we work it
We build Agency-mode systems on Anthropic's Agent SDK and the new Managed Agents primitive — but only after the Delegation question is answered (what should this agent decide on its own?) and the Diligence question is answered (who owns the output, how do we monitor, when do we stop?).
- Agent Teams — multiple Claude instances coordinated by a lead, each with bounded scope and explicit handoffs. No single agent doing everything.
- Adaptive thinking + budget controls — reasoning depth tuned per task, with cost ceilings that make the economics defensible.
- Constitutional guardrails + human-in-the-loop checkpoints — the agent acts within stated boundaries, and high-stakes decisions surface to a human by design.
- Ownership chain documented — when the agent acts, you know who is accountable, and the audit trail says so.
90% faster response times
For workflows where the diligence work is done before the agent ships
AI Governance & Compliance
Where this usually goes wrong
Diligence is the fourth D in the framework — and it's the one most consultancies skip. Creation diligence (which AI, used how), transparency diligence (who knows AI was involved), deployment diligence (who vouches for the output) — all three become legal exposure the moment you scale. Australian regulators are specifically looking for this.
How we work it
We treat governance as the Diligence axis applied to your specific deployment — Privacy Act, IRAP, internal policy, board-level reporting — not as a bolt-on document.
- Constitutional AI alignment — your organisation's values encoded into model behaviour so refusals and escalations match your policy, not the model's defaults.
- Data sovereignty by architecture — processing stays in AWS Sydney (ap-southeast-2), Google Cloud AU, or Azure AU, with the IRAP path documented from the first design.
- Transparency standards — where AI was used, how output was reviewed, who signed off. The deployment diligence trail you'd want if you had to brief the regulator on Monday.
- Claude Code Security — code scanning that uses Claude Opus 4.7 to trace data flows and identify the business-logic flaws static analysis misses.
Privacy Act & IRAP compliant
Aligned with Australian Privacy Act + IRAP Protected-level expectations
Custom Agent Training & Fine-Tuning
Where this usually goes wrong
The off-the-shelf model is fine for general work and bad at your specific work. You don't always need a fine-tune — sometimes a well-described skill, a tight system prompt, and the right tools is enough. Knowing the difference is the Description and Delegation work most teams skip.
How we work it
We start with the cheapest correct intervention — skills, prompts, MCP tools, RAG — and only escalate to fine-tuning or custom small language models when the evidence demands it.
- Description first — system prompts, skills, evals. Most "fine-tune" requests turn out to be description problems.
- Custom small language models — when latency, cost, or domain demands it, we train purpose-built SLMs from open-source foundations with Claude as orchestration + judge.
- RLHF + reward modelling — preference data collected from your team, used to align the model with how you actually work.
- Eval harness in production — A/B infrastructure so you can prove the custom model beat the prompt, instead of assuming it did.
Custom-trained for your workflows
Used only when description + tooling have been ruled out as cheaper fixes
Enterprise AI Observability
Where this usually goes wrong
Once an agent operates on its own, you no longer get to discern outputs in real time the way you did during pair-work. The discernment moves from the human to the system. If you can't see what the agent did, why, and at what cost, you don't have an Agency deployment — you have a liability.
How we work it
Observability is how Discernment scales from the individual interaction to the system. Every agent, every tool call, every reasoning step — visible, queryable, and auditable.
- OpenTelemetry tracing across agent decision chains, with structured logs at every tool call and reasoning step.
- Grafana dashboards for performance, cost, and accuracy that a non-engineer can read in a board meeting.
- Compliance-grade audit trail — session replay, prompt + output capture, tool-use record. Built for regulated environments.
- Drift + anomaly alerting so behaviour change is noticed in minutes, not in a quarterly review.
Complete pipeline visibility
Observability is what makes Agency-mode deployments defensible at audit
Not sure which rung you're on?
Free scope, free build, you only pay if it works. 30-min call books straight to a real engineer.