The autonomous engineering harness
Confixa isn't a copilot that waits for you to type. It's a harness — fourteen specialist agents that plan, build, test, secure, ship, watch and optimise your software, running inside your cloud, under your policy, with you on the gates that actually matter.
Plugs into the stack you already run
Why nothing ships on time
Forty tools, twelve handoffs, and a context reset at every boundary. The work isn't hard — the seams are. Every seam is a queue, and every queue is where your quarter goes.
12
Dev to QA to security to ops to compliance to finance. Each one re-explains the same change from scratch.
800
Scanning finds everything it should. Working out which findings are genuinely reachable is where the time goes.
3 wks
Evidence gets reconstructed by hand, twice a year, from Slack scrollback and screenshots.
0
Teams are adopting AI across the lifecycle with no trace, no budget cap and no replay. That is the next incident.
What a harness is
Confixa, from the Latin configere — to fasten together, to make firm. The agents are the easy part. The harness is what lets you hand them the keys.
A queryable estate graph — services, repos, topology, dependencies, controls, incidents, owners and cost as nodes and edges, persistent and versioned. Agents stop rediscovering your system on every task. Context becomes an asset, not a prompt.
Every capability is a typed tool with least-privilege, per-agent scoped credentials. An agent can only do what it was explicitly handed — and every call it makes is recorded.
Policy-as-code: what each agent may touch, in which environment, at what spend, and what requires a human. Autonomy becomes a configuration you can review in a pull request.
Every decision, tool call and diff is a span. Any run replays end to end, so "why did it do that?" is a thirty-second question rather than a forensics project.
Hard gates on production promotion, schema migrations, IAM and KMS changes, data deletion and spend over threshold. Approve in Slack or Teams, with the full diff and the simulated blast radius attached.
Isolated git worktrees, ephemeral preview environments, sealed networks. Blast radius is bounded by construction rather than by good intentions.
Graph engineering
Services call services. Dependencies carry CVEs. Controls cover systems. Incidents have causes. Owners answer pages. Confixa indexes all of it as one living graph — then never stops adding to it. Every run, review, deploy, scan and incident writes back new nodes and edges, so the graph is a little more complete tomorrow than it is today, and the system a little more capable because of it. Software that gets better the more you use it, rather than the day it shipped.
CALLS DEPENDS_ON DEPLOYS_TO GOVERNED_BY OWNED_BY CAUSED COSTS SATISFIESEvery agent queries this before it acts and writes back to it after. That write-back is the whole point: the Learn beat turns each run's outcome into permanent structure, so a plan arrives already costed, with its blast radius and the owners to notify attached.
The ladder isn't a calendar, it's a consequence. A service earns its next rung when the graph knows enough about it to make the risk legible — which is why trust accrues instead of being asked for.
Repos, cloud, pipelines and telemetry become nodes and edges. The graph is a map: accurate, and shallow.
L0 · observeReviews, test results, scan verdicts and deploy outcomes attach to the things they judged. The graph starts holding opinions, not just facts.
L1 → L2Enough history to see patterns: which changes tend to break, which alerts never mattered, what a fix will cost before it's written.
L3 · gated prodThe graph now encodes your organisation's judgement. A brand-new service arrives on day one already knowing your conventions, controls and rotas.
L4 · in envelopeThe same reason it can't be bought as a finished product, and the same reason switching costs are real: this graph is yours, and it took your traffic to build.
-- "what breaks if I patch this, and who has to know?"
MATCH (d:Dependency { cve: 'CVE-2026-3311' })
<-[:DEPENDS_ON*1..3]- (s:Service)
MATCH (s)-[:GOVERNED_BY]->(c:Control)
MATCH (s)-[:OWNED_BY]->(o:Owner)
WHERE reachable(d, s) -- not merely present: actually callable
RETURN s.name, s.autonomy, blast_radius(s), collect(c), o.rota
ORDER BY blast_radius(s) DESC
before acting
Every plan is costed against the graph first. "This touches two services, one control and the on-call rota" is a sentence a human can approve or refuse in seconds.
security
A CVE in your lockfile is only a problem if there's a live path to it. The graph is how Aegis separates the eight findings that matter from the eight hundred that don't.
compliance
Controls are edges, not spreadsheet rows. Ask which systems a control covers — or which controls a system is missing — and get an answer that's true today.
over time
Every run leaves the graph richer than it found it. The hundredth deploy on a service is reasoned about far better than the first — and that gain is cumulative, not reset by each new task.
The mesh
We went narrow on purpose: fourteen focused agents that each own a discipline end to end, coordinated by an orchestrator that holds the plan, the budget and the gates.
Master orchestrator
Decomposes intent into a dependency graph, routes each task to the specialist that owns it, runs work in parallel where it's safe, enforces the spend envelope, collects the evidence, and stops at every human gate. It also knows when to escalate to you instead of guessing.
Reads the repo, writes the spec and the ADRs, decomposes epics into a task graph, designs schemas and API contracts. Owns the plan everyone else executes.
Writes the code test-first, refactors, runs data migrations and dependency upgrades. Works in isolated worktrees so dozens of tasks progress in parallel without colliding.
Unit, integration, contract, end-to-end and visual regression. Mutation testing to prove the tests actually test something. Flake quarantine and coverage gates that hold.
Branch hygiene, conventional commits, pull-request authoring and review, merge queue, conflict resolution, semver, changelogs and backports. Your git history stops being an apology.
Authors and repairs pipelines, tunes build caching, signs artifacts and emits SBOMs, then runs progressive delivery — canary or blue/green — with automatic rollback on SLO breach.
Terraform and Pulumi authoring, drift detection and correction, environment provisioning, ephemeral preview environments per pull request, Kubernetes manifests, Helm and Argo.
SAST, DAST, SCA, secrets, container and IaC scanning — then reachability triage, so you fix the eight findings an attacker could actually use instead of the eight hundred you can't. Auto-patch pull requests and threat models on every design change.
A unified controls library, continuous evidence collection, policy-as-code gates in the pipeline, and control-drift alerts the day drift happens — not the week before the audit.
Writes the OpenTelemetry instrumentation you never got to, defines SLOs, builds the dashboards, and tunes alerts down — the actual cure for alert fatigue.
Traces and token cost per route, prompt versioning with a real eval harness, regression and drift detection, groundedness scoring, PII leakage, prompt-injection and jailbreak detection, and model routing by cost against quality.
The layer that watches the agents. Full trajectory tracing, loop and thrash detection, blast-radius accounting, per-agent budget caps, autonomy scoring, and time-travel replay of any run. This is the permission slip for production autonomy.
On-call triage, root cause in minutes rather than hours, auto-remediation runbooks, postmortems written while the context is still warm, and error-budget policy that actually gets enforced.
Cost attribution down to the service and the pull request, right-sizing, commitment planning, hot-path and query profiling, LLM spend, carbon. Finds the waste and then opens the pull request that removes it.
CVE and dependency upkeep, end-of-life and upgrade paths, dead-code removal, documentation kept in sync with the code, database index hygiene, and a tech-debt ledger that's actually current.
A day in the loop
A real trace: a refund idempotency bug in a payments service. Scroll to follow it from Jira to a hundred percent of production traffic.
STEP 01 / 09
PAY-2841 · duplicate refunds on retry. Confixa already holds the context: this service, its 412 files, its owners, its SLOs, the two incidents it caused last quarter. Nothing needs re-explaining.
Traces the refund path across three services, finds the missing idempotency key at the boundary, writes the spec and an ADR, and decomposes it into six tasks with an explicit dependency order.
Prices the run, checks it against policy, and estimates blast radius. A migration is involved, so the gate for step 08 is registered up front instead of being discovered at deploy time.
A failing test that reproduces the double refund, then the fix: +182 −37 across four files. Fourteen new tests. Mutation score 91%, so the tests are load-bearing rather than decorative.
SAST and DAST clean. One transitive dependency carries CVE-2026-3311 — reachability analysis confirms it's live on this code path, so it gets patched in the same branch rather than filed as ticket 801.
Signed evidence lands against ISO 27001 A.8.28, DPDP §8(5) and the CERT-In log-retention control. Same artifact, three frameworks. No screenshots, no scrollback archaeology.
A pull request a human can actually read: the reasoning, the diff, the risk note, the trace link. Through the merge queue, pipeline green in 4m 12s, artifact signed, SBOM attached.
Canary at 5%: p99 142ms, error rate 0.01%, SLO held for eleven minutes. Confixa asks in Slack for the one thing it isn't allowed to decide — promote to 100%? — with the diff, the metrics and the rollback plan attached.
Fresh dashboards and an SLO for the refund path. Abacus notices the retry storm was costing ₹18k a month and opens a follow-up. Choir files the whole trajectory — replayable, costed, attributable — into the context plane, so the next fix starts from here.
Three kinds of observability
Classic monitoring tells you the service got slow. LLM observability tells you the model got worse. Agentic observability tells you your automation is misbehaving — and in an autonomous shop, that's the one that saves you.
The classic layer, but instrumented for you rather than by you.
Because "the AI feature got worse" is not a debuggable statement.
The layer we care most about — and the reason your CISO says yes.
The autonomy ladder
Every service starts at L0 and is promoted on evidence, one rung at a time. Set it per service — your billing core can sit at L1 while your internal tooling runs at L4. Breach the envelope and the service drops a rung automatically and pages a human.
Level 0 · week one on any estate
Confixa reads your repos, cloud, pipelines and telemetry and writes nothing at all. In return you get a service catalogue, a tech-debt ledger, a security baseline, a control-gap report and a cost-waste report. Useful on its own — which is exactly how trust gets earned.
Compliance, continuously
A unified controls library where a single piece of signed evidence satisfies CERT-In, the DPDP Act, ISO 27001 and SOC 2 at once. Built India-first, because that's the ground we know best.
CERT-In requires incident reporting within six hours. Medic detects, Ledger drafts the filing with the evidence already attached, a human signs it.
Every check emits signed, timestamped evidence pointing at the exact run that produced it. The audit pack assembles itself.
Controls aren't a document. They're gates: fail the control, fail the build. Drift raises a ticket the day it appears.
Live control coverage, per environment, per framework. The best slide in your security questionnaire response.
Your harness, not ours
Confixa ships with a roster and a point of view. It is still a harness, not a cage — every plane is extensible, and the whole contract for a service is one reviewable file.
Bring your own
Claude, Gemini or self-hosted, routed per task class — cheap models for mechanical work, frontier models for architecture and security reasoning. Your keys, your quota.
Bring your own
Drop in an agent your team already wrote. It inherits the context, policy, trace and approval planes for free, and shows up in Choir like everything else.
Bring your own
Register any internal API as a typed tool with scoped credentials and an audit trail. Your legacy deploy script becomes a first-class capability.
Write your own
Encode your deploy ritual, your review checklist, your naming conventions as versioned skills the mesh is required to follow. Institutional memory that executes.
# One file per service. Reviewed in a PR like anything else.
service: payments-api
autonomy: L3 # observe · suggest · non-prod · gated-prod · envelope
model:
reasoning: claude-opus-5 # architecture, security, RCA
mechanical: claude-haiku-4-5 # lint, docs, dep bumps
agents: [ architect, forge, prover, curator, conductor,
aegis, ledger, lantern, medic, abacus ]
envelope:
budget: { usd_per_day: 40, tokens_per_run: 400_000 }
may_touch: [ staging/*, prod/payments-api ]
never: [ iam:*, kms:*, db:drop*, billing:* ]
gates:
human_approval: [ prod_promote, schema_migration, spend > 250 ]
approvers: [ "@platform-oncall" ]
respond_in: slack#payments-deploys
rollback:
on: [ slo_breach, error_rate > 0.5%, cost_spike > 30% ]
within: 90s
compliance:
packs: [ cert-in, dpdp-2023, iso-27001 ]
evidence: signed
Where Confixa sits
Most of these are best-in-class at what they do, and Confixa is happy to sit alongside them — we read their findings and act on them. What we add is the connective tissue: one governed loop so a change doesn't stop and wait at every boundary.
| Category | Deep at | How Confixa fits |
|---|---|---|
| Cloud security Wiz, Orca | Runtime posture and misconfiguration, at real depth | We consume their findings and carry them back to a merged fix. |
| Compliance automation Drata, Vanta | Evidence collection and questionnaire workflow | We generate the evidence upstream and remediate the failing control. |
| AI coding Copilot, Cursor | Writing code with you, in the editor | We take the same work onward from the pull request to production. |
| CI/CD platforms GitHub, GitLab, Harness | Running pipelines reliably at scale | We author, repair and reason about the pipelines that run on them. |
| IT services partners The large SIs | Breadth, domain depth and accountability | We handle the repeatable loop so their people work higher up. |
| Your platform team In-house | Knowing your estate better than anyone | We give them the harness so they don't have to build one first. |
| Confixa | Ticket → code → tests → security → compliance → ship → observe → optimise | One governed loop, with the gates you deliberately keep. |
The 90-day design partner program
You don't have to believe in autonomous engineering to get value out of month one. Observe-only delivers a real audit. Everything after that is your call, rung by rung.
Days 1 – 30
Connect repos, cloud, pipelines and telemetry. Confixa runs at L0 and writes nothing.
Days 31 – 60
Promote two chosen services to L1 and L2. The agents start doing real work you review.
Days 61 – 90
One service to L3: production canaries with your human promotion gate.
14
Specialist agents across five planes, one orchestrator holding the thread.
5
Autonomy rungs, set per service and promoted only on evidence.
6
Governance planes — context, tool, policy, trace, approval, sandbox.
90
Days from first connection to a gated production deploy.
Structural facts about the product, not customer outcomes. Confixa is in design-partner phase — we'd rather show you a live trace than quote a number we can't source.
Straight answers
Assistants are genuinely excellent at what they do — writing code with you, in the editor. Confixa is aimed at a different part of the problem: it picks the same unit of work up at the pull request and carries it onward through testing, security scanning with reachability triage, compliance evidence, pipeline changes, a canary deploy, telemetry and cost review — as one governed loop with a single audit trail. Most teams use both, and we'd expect you to. The difference isn't intelligence, it's span and governance.
Not to start, and not to be useful. Every service begins at L0 with read-only access. Production write access only exists from L3 upward, is scoped by policy-as-code you review in a pull request, and always passes through a human gate for promotion. Most teams run most services at L2 forever — that's where the toil is anyway.
Your cloud, your credentials. SaaS, a private install in your own GKE project, or fully air-gapped. Bring your own model and your own secret manager. Confixa never needs to hold a long-lived production credential — it requests scoped, short-lived tokens per task, and every issuance is logged.
Five things, in order: the sandbox plane means it's working on a copy; the policy plane means destructive verbs are simply absent from its toolset; the simulate beat prices and bounds the change before it happens; the approval plane blocks the irreversible operations outright; and Choir enforces hard stops on loops, thrash and budget overrun. Then rollback is automatic on SLO breach. We hold ourselves to all six — that's the bar we think production autonomy deserves.
Observability pointed at the agents rather than the application. Every decision, tool call and diff becomes a replayable span, with loop detection, blast-radius accounting, per-agent budget caps and time-travel replay. It answers "what did your AI do in my estate last quarter, and what did it cost?" — and without an answer to that, no security team will ever approve autonomy in production. It's the permission slip, not a feature.
The India pack covers CERT-In directions including the six-hour incident reporting clock, the DPDP Act 2023, and ISO 27001:2022. The global pack adds SOC 2 Type II, PCI-DSS, HIPAA and GDPR. Controls are unified rather than duplicated, so one signed piece of evidence can satisfy several frameworks at once — which is what collapses audit prep from weeks to a download.
Yes, and we'd encourage it. Register an existing agent and it inherits the context, policy, trace and approval planes without changes. Register any internal API as a typed tool with scoped credentials. Encode your own deploy rituals and review checklists as versioned skills the mesh must follow. The harness is the product; the fourteen agents are a starting roster.
They stop being a queue and start being reviewers, architects and owners of the envelope. In practice the job shifts from writing the boilerplate and chasing the pipeline to deciding what should be true, then approving the changes that make it true. Teams that adopt this well don't shrink — they stop having a twelve-month backlog.
One design partner slot at a time
Thirty days, read-only, and you walk away with a real audit of your estate whatever you decide next. That's the whole pitch.