Security-first AI consulting · frontier-tech teams
Your engineers already have Claude Code and Codex. What they don’t have is the routing, memory, enforcement and verification layer that turns a capable model into a reliable colleague.
Fixed scope, quoted per team. No hourly billing. Every artifact is source code in your repository, on a branch, as a reviewable diff.
How one request moves through the harness, from top to bottom. Deterministic steps hold authority; probabilistic steps may only propose. The gate decides before anything executes, so a refused call never runs at all. Only the allowed branch reaches your systems, and then a receipt.
The diagnosis
The model is usually capable of the right answer. What decides whether you get it is everything around the call: whether the constraint from four turns ago is still in context, whether the tool reached the file you meant, whether anything checked the result before it shipped. The teams compounding value from AI are the ones who engineered those parts. The teams that aren’t, blame the model.
At one engineer’s desk it has a texture everyone recognises. The agent forgets a constraint it was given four turns ago. It edits the file that looked right instead of the one that was. It reports a test passed that it never ran. It touches production config because nothing stopped it.
The pattern
Every one of those is a missing mechanism, not a missing capability. The model could have done the right thing. Nothing required it to, and nothing detected that it hadn’t. A harness is the set of mechanisms that closes that loop, and mechanisms are engineering, which means they transfer.
The cost curve
Cost becomes the problem as agents scale. One engineer with one assistant is cheap enough to ignore. A fleet running unattended is not: every retry, every re-read of a file the agent already had, every wide search it should never have run. Routing by difficulty, scoping what each agent may read, and stopping a run the moment a gate refuses it are the difference between a line item and a budget conversation. Cost control is the same engineering as reliability, pointed at tokens.
Four parallel engagements
Most consultancies march you through discovery, then a pilot, then scale. These four run in parallel and are quoted per team, surface, system or pipeline. Take more than one if you have more than one gap.
Your engineers aren't fluent with AI tooling yet
A harness scoped to your codebase: routing, specialist agents, skills, MCP bridges into your systems, and the enforcement gates that keep all of it honest.
Read the engagement →Your AI surface lacks a real threat model
Internal-tool and MCP server hardening, supply-chain review, secret-rotation playbooks. You get remediation PRs and a reviewer checklist you own.
Read the engagement →Your systems know things your agents can't reach
The org brain. Your repos, tickets, docs, instruments and databases made addressable as first-class tools, with canonical contracts between them. Each system keeps its own truth; the layer above derives meaning instead of copying it into yet another store.
Read the engagement →Your team is buried in data plumbing
Close the loop from instrument to answer: measurement ETL, analysis pipelines, generated reporting with drift alerts.
Read the engagement →Harness engineering
Your engineers stop hand-prompting one file at a time.
A library of scoped specialist agents: a security auditor that can only read, a test runner that cannot edit, a reviewer that cannot approve its own work. Plus the procedures they load on demand and MCP bridges that make your own systems first-class tools instead of copy-paste.
Advisory rules are not controls. Gates are.
Instructions in a project file are advisory; the model reads them and mostly complies. An enforcement hook is not advisory. It intercepts the tool call and refuses. Underneath sits one principle: learned state ranks, it never permits. An agent may propose the migration; it is never the thing that decides the migration is safe.
One engineer's hard-won gate becomes the team's gate.
The compounding value arrives when a team's agents share what they learn. Centralising all of it into one graph is the obvious move, and it does not hold: every system's data has to be reshaped to fit the store, the copy starts drifting from its source the day after it lands, and one team's rename breaks everyone else. What survives is federated. Each system keeps its own truth, the shared layer holds the semantics, and meaning is derived on read rather than copied on write.
Runtime agnostic by construction. Agents, gates, doctrine and tool servers live once as versioned definitions and render into whichever assistant your team uses. Adopting a new one adds a render target, not a rewrite.
How the engagement runs
We map what your engineers actually do with their assistants today, where the model holds authority it shouldn't, and how many boundaries the work crosses. Output is a written diagnosis with named failure modes.
Routing, agents and skills scoped to your codebase, doctrine that loads only in relevant context, MCP servers exposing your systems, and the enforcement gates, audit-only on arrival.
Before-and-after measurements on tickets from your own backlog. Every gate is fired deliberately to demonstrate it blocks what it claims to. Not a demo on our machine.
Pairing sessions, office hours and runbooks, until one of your own engineers can extend the harness with us out of the room.
Common questions
Source code in your repository, on a branch, as a reviewable diff: agents, skills, hooks, tool servers, and the doctrine files that drive them. There is no hosted service to depend on and no runtime of ours in your stack.
Initial contact establishes fit and scope. Repository review, diagnosis, architecture recommendations, and other substantive work begin under a paid engagement.
Fixed scope, quoted per team, surface, system or pipeline. No hourly billing. The AI Workflow Audit is the paid entry point for a repository review and diagnosis.
An assessment of the workflows and systems agreed in the scope, an architecture diagram, a prioritized implementation roadmap, and a readout of the findings. Implementation and training are separately scoped unless explicitly included.
HARNESS: 4–8 weeks total. GUARD: 2–4 weeks total. CONTEXT: 6–12 weeks total. AUTOMATE: 4–10 weeks total. These are total-engagement durations, from scope call through hand-off; the fixed-price build sprint inside each engagement is shorter than the total (see the relevant service page). Timelines are anchored to concrete deliverables, not headcount-hours.
The audit identifies what is suitable for agentic execution and what evidence is needed to verify the work. Implementation engagements have their own workload, acceptance criteria, and delivery terms. Completion depends on the actual tasks and constraints, not a blanket guarantee.
Yes. On-site delivery and travel are quoted separately.
The engagement is designed around your systems. Reusable methods and components are adapted to the agreed environment; dependencies and integration requirements are made explicit.
Implementations for Claude Code and Codex, with additional runtimes assessed against their integration capabilities.
The engagement includes a documented process for disabling and removing the installed harness components. Enforcement also arrives audit-only, so every gate is observed before it is allowed to block.
Measure and reduce avoidable retries, repeated context loading, and unnecessary model use. Track cost per accepted task, not just total token consumption.
Only through approved tool pathways that enforce configured permissions before execution. We test those controls against the agreed scope and document their limits.
Tier 1 (proven, multiple shipped projects): Rust and Tauri desktop apps, Next.js + React full-stack, Python automation and ETL, graph databases, MCP server development, LLM integration (Claude, OpenAI, local models), browser automation, self-hosted deployment. We'll tell you honestly if a project falls outside our core stack. No WordPress, no Flutter, no Shopify themes.
Yes. We deploy to self-hosted infrastructure, run local inference for workloads that can't touch hosted APIs, and design reference architectures for cloud, VPC, on-prem, and fully air-gapped settings. Specifics are scoped per engagement.
Every engagement produces reusable artifacts: source code, schemas, tool surfaces, runbooks, and test suites. Your team maintains and evolves the systems independently. Ongoing advisory is available on a monthly retainer if you want continuity.
Under strict Data Handling Agreements. Code and data classification happens before any analysis begins. We prefer on-site or VPN-scoped work for regulated data and default to local inference when required. All artifacts ship with audit logs your compliance team can inspect.
Yes, on a call under NDA. The public site only shows the category of work we do. The shipped code and architectural decisions live behind a mutual NDA. Book an intro call and we'll walk you through relevant examples for your situation.
We build. Every engagement produces code your team reads, runs, and owns, not slide decks. The four service tiers (HARNESS, GUARD, CONTEXT, AUTOMATE) are each a fixed scope with concrete deliverables, not an open-ended retainer. We'll walk through our actual shipped work and architecture under NDA.
The paid audit
One week. $10,000. A defined plan for improving how your team works with AI.
Remote engagement: $10,000. Payment before work begins. On-site delivery and travel quoted separately.
Assessment report
Workflow bottlenecks, automation opportunities, knowledge-access gaps, and weaknesses in verification and control.
Architecture diagram
How agents, people, tools, data sources, and approval boundaries should fit together.
Implementation roadmap
Prioritized changes, dependencies, proposed success measures, and options for implementation or training.
