The work

Three systems in use. Three times I went looking for the flaw myself.

Each of these shipped. Each one has a section where I attacked my own work and found something. That section is the reason to read it.

How I work

Five steps, and the case study where you can watch each one happen.

  1. 01

    Intent modeling

    I watch the work before I scope it. Shadowing the EDI analysts produced the two reframes the whole system rests on, and neither was in the brief.

    EDI Copilot, discovery
  2. 02

    Agent topology

    I decide where the model sits and what it can reach. In EDI Copilot the model runs in one stage, inside a redaction zone, behind a human approval. In Mapping Studio three components are barred from calling a model at all, permanently, by rule.

    Mapping Studio, the system
  3. 03

    System prompts

    The prompt is a contract, not a paragraph. Source of truth scoped to one document, a required citation field, and a named refusal verdict the model must use when that document is silent.

    EDI Copilot, refusal
  4. 04

    Evaluation design

    I build the measurement before I trust the output, then check whether the measurement can adjudicate anything. In Mapping Studio it could not, and that finding changed the product.

    Mapping Studio, evaluation
  5. 05

    Observability

    Every model call logged with tokens, latency, cost and the job that issued it. Every approval and override written to an audit trail with a hash of exactly what was sent.

    Mapping Studio, cost and observability

The demo is about five percent of the actual job.

Anyone can get an agent to work once, on a clean input, in a screenshot. The part that decides whether it survives contact with a real company is the other ninety five percent: the guardrails, the evaluation, the human checkpoints, the audit trail, and the change management that gets an analyst to trust the thing.

That work is invisible until it is missing. My job on a project is to name it early enough that it lands on the plan instead of in the post mortem.

About

I am interested in what goes wrong quietly. An agent that breaks loudly is a nuisance. An agent that drops something and keeps walking is the one that ends a project, and it is the failure I design against.

I do not design from the brief either. Every one of these systems began with somebody describing the work, me going to look at the work itself, and the two not matching. In one case the two things I found there became the architecture, and neither had been mentioned.

I work asynchronously by default. Self contained briefs, locked contracts, a written definition of done, and an append only ledger of numbered rulings, so nothing important lives in a conversation.

How the code gets written, plainly: AI writes it. I direct, review and own every architectural, product and evaluation decision. One system is 22,701 lines of Python with 947 passing tests, built in 26 days, and I never opened an editor. The scarce part of that sentence is not the code. It is the governance that made the code trustworthy.

Away from the desk I ride motorcycles, spend time in forests, and chase anything I have not seen before.

Read the full about page →
Arun Bhisne
Arun Bhisne · Hyderabad

What I get hired to decide

  • Probabilistic behavior and failure design
  • Agent orchestration and topologies
  • System prompting and generative UI
  • Evaluation design and behavioral metrics
  • Observability and reasoning traces

Where I work from

Hyderabad, India. Available across APAC and EMEA hours. If your customers are in Asia or Europe, that is a reason to hire me rather than something to work around.