Your AI agents will fail. That is not a bug. That is the operating model.
For 30 years, enterprise software meant deterministic systems. Press a button, get the same answer every time. Rules engines. Logic trees. If-this-then-that. You tested them to completion and you trusted them because they could not surprise you.
AI-native software does not work that way. Non-deterministic systems behave more like people than like traditional software. They iterate their way into the right answer. The first version rarely gets you there. The second version usually does not either. Accuracy compounds through exposure to edge cases, not through one brilliant engineering sprint.
This is the premise most firms still have not internalized. They keep evaluating AI agents the way they evaluated ERP vendors in 2010: can it do X, Y, and Z on day one, with a 99.9% SLA, under a fixed-scope contract? That framing will lead you to the wrong vendor every time. It will lead you to a system that looks clean on the demo and breaks the moment a real document with a real edge case hits it.
The correct question is different. If the system will iterate, then the question is: how fast can it iterate?
Speed of Iteration Is the Real Moat
Speed of iteration is the real moat in AI-native software. Specifically, three capabilities that most GPs building internal tools cannot assemble:
First, volume of scenarios. A fund admin running an internal extraction script only ever sees their own deal flow. Maybe 40 portfolio companies, maybe 200 if they have been around a while. Every weird SAFE side letter, unusual waterfall mechanic, European fund structure, or non-standard liquidation preference they have never seen is a permanent blind spot. An extraction platform running across dozens of funds sees every one of those patterns. Each new edge case sharpens the next extraction.
Second, observability into every output. When your agent returns a number, you need to know exactly which document it came from, which page, which paragraph, and how confident it was. Without source traceability, you cannot diagnose failures. Without an accuracy score, you cannot prioritize which failures to fix first. Most home-grown extraction scripts return raw values with no provenance. When something is wrong, the analyst who built the script is the only person who can find the bug.
Third, a deterministic review gate. Non-determinism inside the agents is fine. Non-determinism reaching your portfolio system of record is not. Every extraction has to pass through a validation harness, then a human review step, before it can touch the database that drives LP reporting. The agents can be probabilistic. The outputs the firm relies on cannot be.
How GoodStream Is Built for Iteration
GoodStream runs 171 purpose-built extraction agents for private capital documents. Each one is specialized for a specific field or document type. Every output is source-traced to the page and paragraph that produced it. Every field carries an accuracy score. Every document passes a human review gate before it syncs to the portfolio intelligence model. The system is non-deterministic where non-determinism produces value, and deterministic exactly where the firm needs it to be.
This architecture only works if the system sees a lot of variation. A single-fund deployment learns slowly. A cross-firm network learns fast. Our agents now see edge cases from early customers across early-stage VC, growth, and secondaries. When one fund surfaces an unusual structure, the extraction logic improves for every fund. Customer data never leaves the customer. The agents never train on a fund's holdings. What improves is the structural pattern library and the engineered logic: the thing that recognizes "this is a convertible with a most-favored-nation clause" before it tries to pull the cap amount.
A GP building this internally is playing a losing game on every dimension. Lower volume of scenarios. Lower observability. Lower throughput on the review gate. A transparent network where improvements flow across customers beats a closed internal loop. Every time.
Pick Partners on Velocity, Not Tidiness
The firms getting this right are not the ones demanding zero failures on day one. They are the ones demanding fast, visible failures with tight feedback loops. They pick extraction partners based on the velocity of improvement, not the tidiness of the first demo. They understand that the firm with the best failure telemetry ships the best product.
Data transparency is the moat. Horsepower is a commodity. The real question is not whether your AI will fail. It will. The real question is whether the system that runs it was designed to learn from that failure, or to hide it.
GoodStream enters General Availability next month. If you have been looking at internal builds or general-purpose copilots and wondering why the accuracy curve has stalled, it is probably because the feedback loop is too narrow. Talk to us.
See how source-traced extraction agents perform on your own documents. Book a demo.
