Imports that negotiate with the sender's AI agent
A multi-office US property valuation firm needed data from every regional office in one central database, without forcing a template on anyone. The offices increasingly extract that data with their own AI tools, so the import service was built to answer them the same way: machine-actionable findings, including a verdict on whose problem it is. Built by a Pit Wall of two, an AI Product and a Forward Deployed Engineer, with the agent writing the code and no separate Pit Crew, at roughly 5× faster delivery and about 10× the volume of work for the same budget.
Two ways to lose, before you start
Regional offices hold rich property data in heterogeneous spreadsheets extracted from appraisal documents. Consolidating it centrally usually collapses into one of two failures. Mandate a rigid template on every office and adoption dies, because the template never fits how any given office actually works. Hand-map every variant centrally and the cost explodes, while the database schema slowly fills with the quirks of each source.
A third pressure made the usual answers worse: the offices had started extracting their spreadsheets with AI tools of their own. The sender was no longer reliably a person reading an error report.
Standardize the contract, not the people
The import service classifies content instead of matching templates. Sheet names, column headers, and value formats may vary freely; a layered engine of deterministic rules, a domain vocabulary, and a scoped AI fallback works out what the data means.
A stable intermediate format acts as the firewall. Readers absorb source-format drift on one side, and the database writer consumes only the strictly typed intermediate on the other, so source variation and schema evolution stop being each other's problem. The writer never re-parses a string; it dispatches on declared types.
Nothing unidentified reaches the database. An integrity gate validates every import before the write, unresolvable content is quarantined rather than silently guessed, every value carries cell-level provenance, and every import carries an attested record of data origin, which matters when licensed third-party market data is involved.
When the sender is an agent, the error report should be too
The service exposes an agent-facing interface, so an office's own AI agent can upload, track status, read findings, and resubmit end to end. Each finding carries a location, evidence, a concrete suggested action, and a routing verdict.
That verdict is the design decision that does the work. The system can say, in machine-readable form, not your problem, do not re-extract, our importer mis-bound this column. Classic integrations cannot say that; they can only insist the file is wrong. The result is a closed correction loop: a resubmission declares which attempt it supersedes, the service diffs the attempts and reports convergence, or flags a regression when a re-extraction has lost fields the previous one had. Most issues resolve agent to agent in a round or two.
Humans still get a human artifact. The same findings render as the office's own workbook, returned with per-cell comments and a linked issue index. One taxonomy, three renderings: for machines, for agents, and for people.
Two people and the agent
The platform is built by a Pit Wall of two: an AI Product role and a Forward Deployed Engineer. There is no separate Pit Crew. The Forward Deployed Engineer who works out the client's intent is also the one who implements against it, with the Silicon Software Engineer, the AI agent, writing the code.
That is the compression the framework predicts, in its sharpest form. The conventional staffing for a system of this shape, a business analyst mapping every source format, developers building importers, and QA validating the results, collapses into two people who never hand work across a boundary. The specification does not have to survive a translation step, because the person who wrote it is the person who builds against it.
On the delivery estimates for this engagement, that shape is worth roughly 10× the volume of work for the same budget and about 5× faster delivery, at held quality. The triangle moved, and the client took the gain as scope and speed rather than as a smaller invoice.
The same discipline, pointed inside the product
RACE Programming is usually described as how a team builds. This engagement is what happens when the same stance is built into the thing the team ships, because here the AI agent is not only the builder, it is also a participant in the running system.
- The Silicon Software Engineer executes, humans keep judgment. In RACE the agent writes the code and a person owns acceptance. Here the sending agent fixes and resubmits data, while certifying data origin and clearing warnings stay human. Same boundary, moved from the delivery team into the product.
- A specification precise enough for a machine. The Executable User Story exists because an agent cannot build from prose it has to reinterpret. The import findings are the same idea aimed outward: location, evidence, suggested action, and a routing verdict, so the receiving agent can act without a human translating for it.
- Gates, not review by eyeball. RACE puts a four-gate Definition of Done in front of production. This platform puts an integrity gate in front of the database: nothing unidentified is written, and unresolvable content is quarantined rather than guessed.
- Everything as Code. Rules, vocabulary, and provenance are machine-readable state rather than knowledge held by whoever ran the last import, which is what makes the pipeline deterministic and auditable.
Capability, never authority
- An agent can fix and resubmit files. It cannot certify data origin on a human's behalf, and there is deliberately no interface through which it could.
- No agent bypasses classification or the integrity gate, and imports carrying warnings still stop for human review.
- Feedback text is composed from templates and structural fields only. Raw cell content, which an attacker can control, is never interpolated into agent instructions.
- The pipeline is deterministic: the same input against the same rules produces an identical result.
In production, with the humans at two points
The platform runs in production for the firm's regional offices. The domain vocabulary spans roughly nine hundred header aliases and hundreds of normalized enum values, and the system is covered by several hundred tests including a multi-workbook regression corpus. Offices send what they already have; the humans touch the loop at exactly two points, certifying data origin and reviewing warnings.
Client identity withheld. Delivery facts are as reported by the engineering team. The same stance shows up across RACE Programming engagements: agents get capability, humans keep authority, and every automated action is scoped, verified, and auditable.