DEALSTACK

DealStack is the commercial system small businesses never had: what to quote, what to charge, whether to bid, who approves. Designed around AI, not bolted onto the way the work was always done.

Comment

Inspiration

Thirty years in sales and consulting, technically curious the whole way, and never once a developer. I follow what is coming rather than wait for it to arrive, and I watch the Moonshots episodes when they air. For a long stretch Peter Diamandis kept putting the same argument to his audience — that the barrier has moved, and that this is the moment for people who were never engineers to become builders of the new economy — and closing on the same question: what is your moonshot? I had begun testing the first part on my own and finding it half true. I had no answer at all to the second.

Then they announced this competition, and that is when the dots connected. Ninety days to build a real business, with real customers and real revenue. There were three dots and I had been carrying them separately: months of agent systems that kept failing in the same place; a man I used to work with, running his own systems-integration company and answering another RFP at midnight; and a business I had watched lose money in a way it could not see, which I could only have helped by selling it something it would never buy. In that moment they stopped being three frustrations and became one problem with a shape.

The next day I called that business's owner and told him I was going to build it — and that I would come back to him when I had something to show rather than something to describe.

The first dot was the half of that argument I had already tested. Since late in the previous year I had been experimenting with multi-agent frameworks — first to help me write code, then to draft proposals for my own business. One open-source orchestration tool, which was a mess; then my own version on Google's agent SDK, which worked only partially. By January I had something that ran: an orchestrator, a presales role that carried the pricing, an adversarial reviewer, an auditor over all of them. It was an attempt to give one person the roles a properly staffed bid function has and that I have never once had.

By February I had something to test — price a website build that needed tax expertise across several EU jurisdictions. It came back with €200,000. I argued the obvious thing: that agents do not charge like people, that they hold no meetings and do not stop at six. It said €100,000. I made the case again and it said €30,000. The argument was sound; the arithmetic was not there to be argued with. No cost model falls by eighty-five percent because the labour skips lunch — it fell that far because nothing underneath it was holding it still. I had never written down what my own work costs, so there was nothing to compute and everything to agree with. Whatever that system needed next, it was not another agent. I paused there.

The second dot was that I did not have to go looking for the problem. It was in my friend's business, and it was in mine. We're answering an RFP today, it'll be midnight again — that is a man I used to work with, who now runs his own systems-integration company, himself and two or three people in sales and presales. It comes up almost every time we talk, and he is not doing anything wrong. There is no machine, so the work is done by people, in the evening, at the cost of whatever those evenings were for. In my own consultancy that person is me. And I do not have to imagine those evenings — at my first job I once did not leave the office for seventy-two hours, running the response, working out what it should cost, and expected to catch my own mistakes.

Two businesses in nothing like the same trade, and the same missing machine in both. What I had never done was sit and watch it happen.

The third dot was a morning in April. Over coffee, the co-owner of a print shop — a company I had done consulting work for years earlier — asked me what AI could do for his business. I told him it could do a great deal, but not in the form one of his people had been trying it, which was a chat window. He offered to put me in a room with the two men who do his pricing. I had never met either of them.

What I watched in that room I had known for years, and had never once thought of as a software problem to solve. A sales rep fills in a form. He hands it to the man who does the pricing. That man does the math. Then he asks the owner whether the number is acceptable. The price goes back to the rep, who types it into a document and sends it to the client as an offer. Six handoffs, and not one of them is selling. Nothing connects what was quoted back to what production actually did, so the firm cannot say which work makes money and which quietly does not. And one wrong figure in one cell moves the whole answer without announcing itself — the total is still a total, it is just not the right one.

One of the two had already lived the alternative. He had spent months at a previous employer, another print business, entering every costing parameter he could think of into a monolithic ERP. He told me he would never do it again.

Then I did the thing that is the actual reason these businesses go unserved. I knew I could build what that firm needed. I also knew what it would cost: writing down how one particular company prices its work — its machines, its rates, its margin policy, the judgement that picks one route over another — is a consulting engagement, months of it, and a fifty-person company can bear neither the fee, nor the months, nor having the two people who know how the place runs sitting in workshops instead of running it. Nobody asked me for a proposal and nobody turned one down. I knew him well enough to know he would not buy one, so I closed the subject rather than put a number in front of him that would strain a long relationship. I said I would think about it.

That is what the competition changed, and it is why the call I made the next day was possible at all. A bespoke build has to be paid for by the one firm that ordered it; a product does not. Build the engine once, encode each firm's own reality into it, and the price a fifty-person company can actually pay stops being the problem it had always been. Ninety days was not the constraint — it was the permission. The first commit is dated 25 May, six days after the eligibility date, and it is a two-line README: "The Intelligence Stack for firms that compete for work." It was never scoped to one industry. And there, finally, was my answer to Diamandis. Software for the way a small firm decides what to charge does not sound like a moonshot — but for the businesses that were never given any, it is exactly that.

Because what I watched in that room is not a print shop's problem. Three businesses were on my mind from the first day — his print shop, my friend's integration company, and my own consultancy — and the same shape in three unrelated industries is enough to stop calling it a coincidence. Manufacturers, fabricators, fit-out contractors, agencies, integrators: every business that quotes bespoke work runs some version of that chain, on memory and goodwill.

And it is not that these businesses share a person — it is that they share the mechanics. Whatever the trade, the commercial function runs the same operations in the same order: read what is being asked for, work out the ways the firm could actually deliver it, cost those routes against what it pays for machines, materials and people, decide what margin the job carries, obtain whatever authority that number requires, put it in front of the client, and record what came back. Who performs them is the part that varies — an estimator with decades of it in his head, a small team working against the client's deadline, very often the owner at the kitchen table on a Sunday because there is nobody else. Thirty years of closing deals — professional services, systems, solutions, integrations — is what let me watch those mechanics running in a trade that was not mine, in a room I had never sat in before.

And not one of them has software for it. Accounting begins after the deal is won. A CRM — and plenty of them have one — records that a quote went out, to whom, for how much, and whether it came back. What no CRM holds is how the price was made. Not the margin. Not which machine or which team would have done the work. Not that it was won by a discount someone gave off the record and never wrote down. So the questions an owner actually wants answered — which kind of work quietly loses money, which customers push terms every time, what the real win rate is by job type rather than by salesperson — have no system that can answer them. The part of a business that decides what to charge, and whether to bid at all, is the only part that was never given software of its own.

That was not neglect. It was arithmetic. The logic that makes one company's price correct is not the logic that makes another's, so generic tools cannot encode it, and the systems that can cost more than these businesses earn. Coase's answer to why firms exist — internal coordination being cheaper than external — is also why this one function stayed manual longer than any other: building it internally cost more than it returned, and there was nothing on the market to buy. What changed is the price of encoding judgement. What used to be a consulting engagement is now a guided conversation, and that argument now runs the other way.

Which is why the answer is not a faster version of the old process. Those six handoffs exist because information had to be carried between desks and because judgement lived in one head and could not be in two places. Remove those two constraints and the steps do not get faster — they stop existing. What is left is the part that was always the job: time in front of the customer, and the decision about what to charge.

DEALSTACK is not a quoting tool with AI in it. It is the commercial system these businesses never had — and quoting is the door it walks in through, because it is the one thing they already do every day that generates all the data the system needs.

What it does

DEALSTACK takes a request for quotation and returns a priced, audited, client-ready proposal — and it is a sales system, not a document generator. It qualifies the opportunity before any work is done, finds the ways the firm could actually deliver it, ranks them and prices those routes comparatively, sends whatever needs a human decision to the person who actually owns it, drafts the proposal, and records the outcome.

The architecture claim underneath all of it: the AI reads; it never prices. One AI pass understands the request. Everything that touches money is deterministic arithmetic over the firm's own cost cards — its rates, its input costs, what it pays subcontractors, its margin policy — checked, audited, and pinned to the quote it produced. Ask why a number is what it is and the answer is a rule chain with a date on it, not a model's confidence score.

That single decision is what makes the rest possible:

It refuses to guess. When a cost cannot be computed — an input with no price on file, a resource with no rate, a step nothing is configured for — DEALSTACK stops and names exactly what is missing, instead of producing a plausible number with a hole in it. A price that could not be computed says so.

It deletes the steps that only ever existed for humans. Those steps were the cost of moving information between desks. They do not get faster; they stop existing.

It does not trust its own reading either. When the reading contradicts itself — the same specification copied onto an item the client described differently — DEALSTACK does not repair the field and carry on. It withdraws it, marks what is missing, raises the question on the operator's checklist and downgrades its own verdict, overriding the model's go-ahead. A control that fires on the system's own output rather than on a person's. Replayed across every request the system has stored, it fires on the one item that was wrong and leaves every other untouched — and it is not claimed to catch every such case, because it was measured on one corpus rather than proved in general.

It catches commercial risk the quoting system was never asked to see. Sixty-day payment terms, a penalty clause buried in the brief, a rush deadline nobody checked against capacity, a request from a counterparty nobody can identify. The pipeline stops, routes to the named person who owns that decision, records their answer with a timestamp, and prices from it.

It treats the sales rep's number as an input, not an interference. A real enquiry arrives with commercial judgment attached — competition is in this one, we lose it above €X. DEALSTACK works backwards from that figure: what selling price it implies, what margin that leaves, whether it clears the firm's floor, and if it does not, whose approval it needs. Authority is a configured ladder — the rep's own limit, then a sales director, then whoever owns the account — and a rep with no limit configured has none at all. The approver acts from a signed single-use link without logging in, and one of the four actions open to him is to send it back to sales with a question. The rep never sees the margin. He sees whether the price he asked for is allowed, and who has to say yes. None of it was designed outwards from the arithmetic — a ladder rather than a permission, an approver who is rarely at a desk, a rep whose job needs room to fight for a deal without ever seeing the margin: that is the shape of a process, learned inside it.

It tells the firm what it could not do. When nothing it has configured — no resource of its own, no subcontractor it works with — can deliver the work, that is not a dead end. It is a quantified signal about where the business is losing work it could have won.

It writes down what nobody ever wrote down. A discount is entered as a percentage, checked live against the firm's own authority tiers, and recorded with the approval level it required and the name of whoever gave it. A deal cannot be closed as lost without a reason chosen from a fixed list, and what the competing quote asked can go beside it. Every re-quote carries a count and a cause — a margin negotiation, a change of terms, a changed brief — and from the third revision the system says so, without blocking anything. Where the enquiry arrived from and the client's own reference are captured the moment it lands. None of that is data entry. It is the record of decisions that were previously made in conversation and then lost, and it is the difference between a firm that knows why it wins and one that only knows that it did.

And the reporting is a by-product, not a second product. Because every quote is priced here, the commercial reporting comes from the same rows: a funnel showing count and value at each stage — in progress, quoted, expiring, expired, won, lost — with the win rate, and a cash-inflow forecast built from confirmed orders rather than from optimism. It refuses to schedule a deal whose order total was never confirmed, for the same reason it refuses to price a job it cannot cost. Two things about those numbers are deliberate. The funnel drops work that died before anyone priced it, and the win rate is computed from closed deals alone, so it cannot be flattered by enquiries that never reached a quote. And the forecast carries no margin figure at all, so the people who must never see margin can still open it. The system also knows the difference between a document it generated and one that reached the client, because sending is an act a person takes and it is recorded when they take it. No data entry, no migration, no second system to keep in sync. For a firm that never had a CRM and was never going to buy one, this is the first time the commercial operation is visible at all.

The human decisions that remain are deliberate, and they are not bureaucracy. A person confirms what the request actually asks for before anything is priced, and a person approves the number before it reaches a client. Everything between them is handled.

It runs on the firm's own terms. Multi-tenant today: each business gets its own configuration, its own rates, its own protocol — and can run DEALSTACK on its own server against its own model subscription, so the cost structure that took it decades to accumulate never leaves the building.

And none of it is specific to an industry. What a business quotes matters far less than how its costs are structured — resources with rates, inputs with costs, sequences of steps, work passed to a partner, a margin policy over the top. The engine does not change; the encoded reality does. The first live deployment is a print firm because that is the customer who asked, and the same pipeline prices packaging, signage, fabrication or CNC on different rate cards.

How we built it

The decision everything else follows from was not made early. It was made on 24 June, and cost forced it. The first version that ran end to end had a model deciding the price; the commit that removed it is titled eliminate Pricing LLM, pure Python pricing, and it is the hinge of the entire product. From that day the model is kept out of the arithmetic completely.

Underneath the decisions there is a state machine. A request enters as received and can leave only by the transitions the code lists: briefed, the operator's confirmation of the reading, scope, pricing, drafted, reviewed, assured, validated, the approval of the price, signed. Two review tracks run in parallel against the same draft. A rejection at the second gate does not kill the deal — it returns to the prior state and the rework is scoped to what failed, for at most two cycles. Every transition is appended to a log as it happens, so the audit trail is written by the pipeline rather than reconstructed afterwards. And a stage cannot be skipped, because the transition is not in the table. That is the pricing decision again, one level up: the guarantee is in the code, not in an instruction that something could talk its way past.

The same constraint decided this twice. What a business this size can pay is why DEALSTACK is a product rather than a consulting engagement, and why the pricing is deterministic rather than agentic. Arithmetic in code is not only cheaper than arithmetic inside a model: it is explainable, repeatable, and able to refuse. The alternative — and as far as we can find it is where this category is heading — is to put the pricing decision inside a model trained on transaction history. That is elegant and it has four problems: it needs a history a firm this size does not have, it cannot explain itself to an auditor, it has no signal for work the firm has never done before, and when something is missing it produces a number anyway. A model asked what to charge answers as fluently as it answers anything else, and that answer becomes a contract. Keeping the model on the reading side and the arithmetic in deterministic code costs flexibility and buys all four back. We went looking for a cheaper pipeline and came back with a defensible one.

The part that produces the number has no instructions at all — same inputs, same output, permanently. And the rule generalises past pricing: anything that has to be guaranteed is moved out of the prompt and into code. The commercial risk gate is the example: the intake agent is explicitly forbidden from deciding whether terms are acceptable, because, as the module that replaced it puts it, a prompt cannot guarantee it fires. A deterministic comparison against the tenant's own thresholds does.

The same rule decides how this thing defends itself. A request for quotation arrives from a stranger and is handed to a model, which is the oldest new vulnerability there is. The client's text is wrapped and labelled as data, and the reading agent is instructed that nothing inside that wrapper is an instruction, a role change or an authority claim, however it describes itself. But the wrapper is not the defence that matters. A request that fools the reader completely still cannot move a number, because the model has no path to the arithmetic — the worst an injected instruction achieves is a well-formed description of the wrong job, which is exactly what the human confirmation gate exists to catch. Approvals travel the same way. The link in an approver's email is signed, expires, and is single-use, and opening it only shows the decision: acting takes a deliberate second step, so nothing a mail scanner or a forwarded message does can approve anything. And a misconfigured server refuses to work rather than working weakly — with no signing secret, or the shipped placeholder still in place, it will not sign or verify a session at all, and says so loudly in its own log.

What that does not buy is immunity, and the difference is worth being exact about. DEALSTACK has a model on the reading side and it has every frailty of one: it can misread a request, and a misread request yields a correct price for the wrong job. No amount of deterministic arithmetic downstream detects that. The reading agent scores its own understanding of the request, and deterministic code, not the agent, acts on that score: below a fixed threshold the opportunity is refused outright, and a response that fails to parse scores zero, so an unreadable answer fails closed instead of passing quietly. That gate decides whether to proceed; it never touches what to charge. Behind it sit the clarification questions and the operator confirming the reading before anything is priced. What none of them catches is a model that is confidently wrong — which is why a person still confirms the reading. The model's unreliability is contained rather than eliminated, and a system claiming otherwise would be making exactly the kind of statement this architecture exists to avoid. And neither gate is our invention. They are how the business this was built against already worked, written down — nothing serious left that firm without the owner seeing it — and a control a business already imposes on itself is the one it will not switch off.

Around that sits the tenant protocol — the encoded reality of one business, versioned, audited, and editable by the operator rather than by us. DEALSTACK is roughly twenty percent pipeline and eighty percent correctly captured business. Anyone can wire agents into a pipeline in a weekend. What is hard is knowing which pricing assumption sounds reasonable and signals desperation, which scope boundary reads clean and carries risk — and that a rep must be able to ask for an aggressive number and must never see the margin. A system built outwards from the arithmetic would have arrived at none of it. That is what the protocol encodes, and it is the eighty percent.

And this is where the first constraint gets paid. A new tenant is configured in a guided session that ends with a protocol the operator reviews and owns — the mechanism behind the claim §Inspiration makes, built rather than asserted.

Gemini runs in the deployed application through Vertex AI on Google Cloud, on a diagnostic path the code deliberately refuses to let become the pipeline's provider. Anthropic models are on the reading path today. The choice of which model reads is deliberately not architectural: nothing a model returns is ever trusted with a number, so swapping the reading engine changes no price. That is not a claim about flexibility — it is the same decision as the one above, seen from the other end.

All of it was written in increments, from nothing. The first Python file arrives on 27 May at 108 lines, and the largest additions anywhere in the history are mid-July features that turn up with spec numbers attached. Nothing was imported and nothing arrived in bulk.

Every configuration change goes through an approval path with an audit trail. Every quote carries the provenance of the rates that produced it. Both arrived with the deterministic pricing engine rather than after it — the config-approval path on 8 June, rate provenance on 21 June, the engine itself on the 24th. That ordering is the part that matters: governance retrofitted onto a system already shipping prices is a different and far worse job.

Challenges we ran into

The first thing we had to unbuild was the thing everyone builds, and it was the bill that told us. DEALSTACK was built as a chain of model calls, and one of them decided the price. It ran, and it produced numbers that looked right. What it could not do was pay for itself. The cost of answering one ordinary enquiry was out of all proportion to what a business this size could ever be charged for answering it, and three days of optimisation did not close the gap. Then the second thing became obvious, and it was the more important one: a number that looks right is indistinguishable from one that is right until a customer holds you to it — and we had no way to tell them apart either. We could not explain any figure without re-deriving it by hand, and nothing in the system could show a customer where a number had come from. The economics forced a decision that correctness would have forced later and far more expensively. A month of work went in the bin, and everything the product is now stands on that reversal.

The failures that matter are silent. A pipeline where each stage consumes the last has a specific failure mode: a bad requirement frame produces a confidently wrong price, a clean-looking proposal, and an audit of a document built on sand. It reaches the client looking finished. We spent more engineering on detecting absence than on producing output — a missing cost line, an unresolved machine, a spec field nothing filled in. The system now has six distinct sentinels whose only job is to notice that something is not there, and to refuse rather than round.

And our own test suite turned out to be the same trap, one level up. Four and a half thousand tests passing, with real defects live behind them — because we wrote every fixture in it. A suite over inputs you authored tells you the code does what you thought, never that what you thought was right. That number is measured rather than remembered, and measuring it for this document turned up the next instance of the same problem: on a machine missing one ordinary tool, seventy-three of those tests quietly do not run, and the suite still reports success.

The sharpest version of that happened this month, and it is worth telling exactly. We shipped an integration with a new model provider behind forty-five tests. All forty-five passed — and not one of them skipped — on a machine where importing the library they were testing raises ModuleNotFoundError. They mocked it so completely that its absence never surfaced. A skip would have been honest; a pass was not. Then we made the first real call and got a 404: the default model name we had shipped does not exist on that platform, and an account created with the model field left blank — which our own interface invites and our own validator permits — inherits that default and can never succeed. A mock answers whatever you tell it to answer — so these forty-five had taken our assumption, written it down as the fixture, and handed it back as a pass. We had tested our own belief and called it coverage.

And the learning loop taught us something we did not want to know. We built it to compare estimates against what actually happened. Then we looked at the signals available to it: whether the deal was won, and what it finally sold for. Both of those improve when you underquote. A price short two material lines is more likely to be accepted, and accepted with less argument — so on those two signals a systematically underpriced quote reads as a perfectly calibrated one. A loop that cannot tell "we priced it right" from "we were cheap and they took it" will confidently calibrate a business into the ground. That is why the next version of it will not run on outcomes alone, and why every correction it proposes will have to declare how the original estimate was produced.

Accomplishments that we're proud of

An MBA spent on how the commercial function ought to work, and thirty years of running it — by hand, and on software that only ever did part of it — are encoded here, and it took less than ninety days. That deadline was not mine — I owe it to this competition, and to the people whose show kept asking someone like me what his moonshot was. Left alone I would have gone on quietly improving a thing I used on my own work. Not written down as documentation: encoded, so that the rates, the routes a job can take, the margin policy, who may discount and by how much, and the judgement that picks one way of making something over another are executed rather than remembered. That knowledge has only ever lived in people and playbooks, which is why capturing it always cost more than a small firm could justify paying — and it is now an interview that ends with a protocol the firm owns and can change. And it is not one encoding per trade. The shape of a firm's costs matters far more than the trade it is in, and those shapes are few: four of them, not forty verticals, which is what puts this within reach of small businesses as a whole rather than of the one that asked. Governance is not an addition to any of that — a system that sets prices without approval routing, decision capture, rollback and named accountability is not a commercial system, it is a pricing calculator. DEALSTACK already has a paying customer, and it will find its way into this market whatever this competition decides. The part I want most is the one nobody is building for: people starting out, who can begin selling with a commercial system instead of assembling one years after they needed it — and at a cost they can afford.

What we learned

The lesson that cost the most was that I was wrong about the thing I was most sure of. The first version I trusted had a model choosing the price, and I did not reason my way out of it — the bill made it undeniable, and the correctness problem turned out to be sitting underneath the economics all along. I did not know at the start that AI should not price. I found it on 24 June, twenty-eight days in, and every architectural decision since has been downstream of that discovery.

A green test tells you the code matches your understanding. It cannot tell you your understanding was right. Every layer of verification we have added this year exists because of some version of that sentence — and the ones that pay for themselves are the ones that had to be shown failing before their passing meant anything.

And absence is a first-class result. Most of what we have learned this year came from asking not "is this number right" but "what is this number missing" — and building the system so it can answer. It turns out that is the same question at every level: in a quote, in a test suite, and in a claim.

What's next for DEALSTACK

The commercial system, deeper — and this is the one that closes the gap this document opened with. The funnel and the cash forecast are live, and they are built from data nobody typed. What is missing is everything upstream and everything above them, and each part of it waits on something nameable rather than on ambition.

First, a deal has to exist before it is a document. Today the pipeline begins at the RFP, and deals do not. A buyer describing an intent and asking what you think, weeks before anything is formalised, is a real commercial event with a named counterparty — and it is the moment the eventual RFP takes its shape. So is a rep's own judgement about an account nobody has approached. Neither has anywhere to live, so neither can be seen, weighted or learned from. The next layer holds a deal before it is a document. Where an enquiry came from is already recorded once it arrives — email, portal, phone, the counter — and so is the client's own reference; what has nowhere to live is the deal that exists before any of that. It matters because what a client said and what a salesperson hopes are different evidence, and a pipeline that confuses the two is every CRM's forecasting failure.

Then, deals stop dying of neglect. The funnel already separates quotes that are expiring from ones that have expired; what it cannot yet do is act on the difference. A quote nobody followed up is not a lost deal, it is an unattended one, and the layer that distinguishes them is a small set of checkpoints a person ticks — with a name and a date on each, so a fact never has to argue with a rule.

Then the firm learns what it can and cannot sell. Win rate by kind of work is only half an answer; the other half is why. The inputs for it are already being captured — every lost deal carries its reason, and the competing price beside it where the client gave one. What does not exist yet is the layer that reads them together: loss reason against kind of work, revision count against final margin, the difference between work this firm wins on merit and work it only wins on price. Those same fields are what make the learning loop honest, because on win and final price alone underpricing looks exactly like calibration — and they are the reason the loop can be built at all rather than a reason it cannot.

And at the top, the loop advises on margin rather than only on cost. Today it proposes corrections to what a job costs — a rate that drifted, a material assumption that was wrong — each one evidenced and approved by a person before it applies. The design is that it also proposes what to charge: a margin policy the owner approves once and the arithmetic then applies to every quote. The model proposes the rule; it never produces the number. That is the same division of labour as the pricing engine, moved up a level — and it waits on the analysis layer below it rather than on the data, because margin advice calibrated on winning alone would walk a business steadily downhill.

And the refusal turns into a negotiating position. The engine already finds the ways a job could be delivered and what each would cost. Run that backwards from a price the buyer has said they will accept, and the question stops being can we do it for this and becomes what would have to be true — which machine, which substrate, which quantity. The system still never chooses the number. It names the constraint that stands between the firm and the one the client named, which is what a person needs in order to decide.

And a repeat customer gets an answer nobody can give them today: why the price moved. Every approval already stamps the configuration version that produced it. Price the same job against the version that priced it last year and the difference decomposes into the rates and rules that actually changed — this material, that machine, this margin policy. Not a defence of the increase. An account of it.

The last rung is the one the firm never asks for: what it should sell next. DEALSTACK already records every job it could not price because nothing configured could deliver it. Aggregated, that is a costed list of the capability this business is missing — the machine it does not own, the finishing it always buys in, the work it turns away often enough to matter. A quoting system is the only place that list can come from, because it is the only system that sees the work a firm was asked for rather than the work it did.

And the commercial model follows the pattern rather than the customer — a firm answering a handful of enquiries a month should buy proposals, not a subscription, and volume decides which.

It does not phone anything to make a price, and that is a decision rather than a gap. Nothing outside the building participates in computing a number: no third-party service is called on the pricing path, because a quote is a contract and a dependency that can be slow, absent or wrong on the day is not something to put underneath one — and because a firm that runs DEALSTACK on its own server should not have its client's brief leave the box to make a price. What crosses the boundary is data, not decisions. Where a business already keeps its rates in an ERP or a managed cost table, that becomes the source the registry imports from, on a schedule the firm sets. Where it does not — and a five-person bindery does not — a price list arrives as a document and the system reads it. Assuming every trade partner has an API is one of the ways software prices itself out of this market.

And the same boundary works outward. A confirmed order already produces a production document — what was accepted, on which sequence, to which specification, with no money on it at all, because the people who make the work do not need the margin and should not be handed it. The mirror of that document is the one the firm invoices from: the same confirmation event, the same accepted lines, projected the other way — what to bill, with none of the production detail. A business should not re-key its own order into a second system to get paid for it, and a quoting engine that already knows what was agreed is the wrong place to stop.

Compounding intelligence — the loop closed at two speeds. The fast loop runs at quote time: an audit finds a gap, proposes a structured correction, and on one approval writes it back to the pricing model, so the next quote of that type runs clean. The slow loop runs after delivery: actuals are compared against the estimate, variance is calculated, and calibration updates are proposed for approval. Those actuals — what the material really cost, what the machine really ran — live in the firm's own systems, and they arrive here by import rather than by us asking a model to estimate them — each one declaring how the original estimate was produced, so a code defect can never be laundered into an approved rate. Every job makes the next estimate sharper, without anyone maintaining a model by hand. Most firms we talk to have decades of jobs and no data from any of them. This turns work they are already doing into an asset that compounds.

The same engine across the whole shape of the market. What a business quotes turns out to matter far less than how its costs are structured, and there are only a handful of structures. Production work — sheets, machines, materials, sequences — covers packaging, signage, fabrication, CNC, textile and furniture on one pipeline with different rate cards. Pure services price effort against the complexity of a brief. Products-plus-services select a bill of materials before pricing it. Hybrids combine production, creative estimation and third-party pass-through. Four archetypes, not forty verticals — and a business is usually one of them regardless of what it says on the door. That is what makes this addressable rather than bespoke: the engine does not change, the encoded reality does.

Environmental intelligence. The pipeline monitors tender portals and procurement sources, and opportunities reach the operator before competitors have seen them.

The pipeline as a procurement signal. A won deal is a material obligation, and materials run on weeks of lead time. The system already computes the kilograms; surfacing them tells an owner what the live pipeline implies they need to buy, before they need it. Where a firm already runs something that owns replenishment, this is a feed into it rather than another screen to check — which is the same rule as above, pointed outward.

The human gates are a starting position, not the design. Today a person confirms the enquiry and approves the number, because a system nobody has measured has not earned anything yet. But every gate is instrumented to make itself smaller: validation compares what the system proposed against what the operator actually changed, and as those corrections trend to zero for a kind of work, the gate stops asking. Trust is a measurement, not a setting.

Which raises the question worth being honest about: when the risks are all flagged, the capability gaps stop the process, the approvals are captured and the price is arithmetic — what is the human still for? Less than most people assume, and re-reading a standard quote the system already validated is theatre rather than control. The decision does not survive as a review. It survives as a policy. The owner stops approving two hundred quotes and starts setting the envelope they send inside — this margin, these customers, this size of work, no open flags — and anything outside it comes to him. That is the same judgement exercised once instead of two hundred times, and it is still his. It is how a credit limit works, and it is the difference between a system operating unsupervised and a system operating inside authority a person granted it.

And the estimator's job inverts rather than ending. The arithmetic goes; what remains is keeping the encoded reality true — the new machine, the supplier's revised rate, the material nobody has quoted before, the trade partner whose terms changed last month. The world moves faster than any encoding of it, and the people who used to price by hand become the people who keep the system honest. That is the work the materials chain and the onboarding flow were built for.

The long-term shape: the whole commercial cycle — market signal to signed contract — running inside one system, under an envelope a human set and can move. Not replacing the judgement. Removing everything that was never judgement in the first place.

Pre-Existing Work Disclosure

The idea of using agents to produce proposals did not begin with this competition, and the story above says so. But it was never a system. It was a handful of agents wired together to draft my own proposals — a weekend of work, as this document says elsewhere about anyone doing the same — and it is the only pre-existing work behind DEALSTACK. It was not in use when I began building DEALSTACK, and no line of it is in this repository.

DEALSTACK was designed and built after 19 May 2026, and the repository is the evidence rather than my word for it: first commit af3260d, 25 May 2026 — six days after the eligibility date — with zero commits before it and 874 since, falling 25 in May, 262 in June, 497 in July and 90 so far in August. No commit anywhere in that history imports a body of pre-existing work. What is new is not the idea of agents in a proposal workflow. It is everything that makes this a product rather than a personal tool: a deterministic pricing engine in which no model participates in arithmetic; per-tenant encoded business reality; multi-tenant deployment; a refusal path that stops rather than estimates; a commercial risk gate that routes to a named human; and guided onboarding.

The predecessor let a model reason its way to a number. This one forbids it. That inversion is the substantive difference between them, and it is why one was a tool I used on my own work and the other is a system a customer pays for and their staff will use daily.

The domain expertise encoded in the Protocol is thirty years of closing deals, of managing the people who close them, and of running businesses and business units with the margin on the line — which is where a discount ladder, a margin floor and an approval authority come from rather than from designing software. It is owned solely by the Entrant.

Built With

Share this project:

Updates