Contract engineering · Jonis Fields · remote · async · fixed scope

I take agent and LLM systems from “works on a laptop” to a deployed service — and I prove it shipped.

Two hosted exhibits carry the commit hashes, the test files, the line counts and the running revisions, and every fix in them was confirmed against the platform rather than inferred from a fast response. Three defects found and closed across two production services, three of three verified live. One autonomous repair loop with 75 tests, 21 of 21 deliberate mutations caught, and zero merges — because it is not allowed to merge. If a claim on this page is wrong, you can falsify it in about two minutes.

TypeScript · Next.jsPythonServerless containersMCP / agent APIsTests that can failRemote · async · written
3 / 3
fixes verified live on the running platform, not inferred
8
defects closed in one browser-walk pass
21 / 21
deliberate mutations caught by the test suite
0
merges by the autonomous repair loop, across 5 live runs

Every figure on this page is read from one of the two exhibits below.

What I do

Four engagements. Fixed scope, fixed price.

Each one is the thing an exhibit already shows me doing.

Production Readiness Audit

$4,500 · 5 business days

Your web application, walked the way production walks it: every distinct page template, console errors, failed network requests, missing assets, broken interactive components, error paths, deploy repeatability. Written findings, prioritized, with the fixes specified.

The evidence — Exhibit C is exactly this pass run against one of my own Next.js applications. It surfaced eight defects — including an API route returning non-200 in a state the tests never exercised, and a crawler-policy setting where the repository and the live edge response disagreed. I checked which one was correct instead of editing the code to match the wire; the repository was right. Fixing the symptom would have made the code wrong and the tests green. Exhibit C →

Start here if you don't know where to start. It is small enough to approve and it usually finds the bigger job.

MCP / Agent API Security and Governance Assessment

$7,500 · 10 business days

One MCP or agent API surface, up to 10 tool endpoints. Five-area review. Written findings with severity, reproduction steps and fix guidance. One re-test within 30 days.

The evidence — I ran this against my own production endpoints and it found two real defects. Exhibit A — a handler that validated argument shape but never argument presence: a malformed value was rejected cleanly, an omitted value skipped validation and surfaced a raw runtime error. Exhibit B — a malformed request body never reached the handlers at all; the framework's default error handler answered first, with an HTML page carrying a server-side stack trace. Every handler test passed, because the bug lived in the layer before the handlers. Exhibits A and B →

Also on AWS Marketplace if your team would rather put it on the AWS bill you already pay. Request a private offer there and it is issued under your existing AWS agreement.

Agent-to-Production Sprint

$12,000 · 2 weeks

You have an agent or LLM feature that runs on someone's machine. I make it a real service: deployed, authenticated, rate-limited, error-handled, monitored, tested.

The evidence — Both defects above were found, fixed at the root, locked with regression tests and deployed — Exhibit A behind two shared guards applied across all three handlers carrying the same bug, with a new 123-line suite passing 6/6; Exhibit B as an additive middleware, then a catch-all when a re-audit found the sibling error class, suite 14/14. Both retested against the running service and the live revision confirmed on the platform. Exhibits A and B →

Overflow / subcontract

$150 / hour · 20-hour minimum

For shops with more work than hands. Remote, async, short notice. Shipped code against your own repository and review process.

How I work

The rules I hold myself to — with their real scope.

Verify, never infer.

A fast response does not mean your code is live. Before I say anything shipped, I check the platform for the running revision. Every fix in Exhibits A–C was confirmed that way, three of three.

Every logic fix lands with a regression test — and I test the tests.

Surface fixes like Exhibit C's are locked by re-running the browser walk, and I say so. A test suite that restates the code passes when the code is wrong, so I break the guarantees on purpose and re-run: 21 mutations introduced, 21 caught. Two of them were caught only by tests I had to write for them. The mutant found the missing tooth.

Fix the class, not the instance.

Exhibit A appeared in one handler and was fixed in three. Exhibit B is the counter-example that proves the rule: the first fix guarded one error class, the re-audit found its sibling, and the cure was a catch-all. A bug that exists once usually exists three times.

Prefer additive changes.

Exhibit B's first fix was +45 lines, 0 deletions — no existing branch modified. Additive is not risk-free, but it keeps the blast radius legible.

Propose, never merge.

The autonomous repair loop in Exhibit D outputs a diff and a red-to-green receipt for a human to read. There is no code path in it that applies, merges, pushes or deploys, and a test scans the package source to prove that capability stays absent rather than merely unused. Across five live runs against real models: zero merges. I build the cage before the animal, and I apply the same rule to your repositories.

On any surprise, stop and write it down.

Six defects in Exhibit D were found by tests and live runs of my own system — an audit field that always read 0 because it measured after the write; build artifacts riding in a diff and defeating an empty-diff safety check; an environment that would have let the gate test the wrong code and go green; a termination signal leaving a worktree behind; an accepted edit that changed nothing; and a headless model call that turned out to be carrying its operator's local notes. Each became a numbered defect and a test that fails if the fix is removed. None of those were in the happy path. That is where the useful failures live.

Remote, async, written. One engagement at a time.

I work in writing on my own schedule, which is the whole point if you are buying overflow capacity. You get findings you can forward, not a meeting you have to attend. I do not run two engagements at once.

The exhibits

Read the work before you talk to me.

Exhibits A–C — three production defects: found, fixed, tested, deployed →

Commit hashes, test files, line counts, the revisions each fix shipped in — and two commands a stranger can run against the live services. Two production services.

Exhibit D — an autonomous repair loop that proposes and never merges →

75 tests · 21/21 mutations caught · 5 live runs against real models · 0 merges — and the six defects the loop's own tests caught in the loop itself.

Why you can see any of this: these are production systems I own and operate, so nothing is redacted — and the running behaviour is public, so two of the claims can be checked with a single command each. The repositories are private; read access on request.

Send me the surface you're worried about.

A URL, a repo, or two sentences about what's breaking. I'll tell you which of the four engagements fits and what it costs — or that none of them do.


Jonis Fields · Bonis Systems LLC · Every number above is read from the exhibits; nothing is estimated. Page published 2026-08-16.