% man AI++
TL;DR: AI++ runs business processes end to end — including the parts that wait on people. An LLM writes the process in a DSL; a compiler proves that process sound before it is allowed to run; every step is checked by a separate evaluator as it goes; and each run leaves a complete record of what happened. Target customers: firms and operators whose real cost is coordination.
Most enterprise agent projects fail, and the reasons are published rather than mysterious. Forrester and Anaconda put 88% of agent pilots as never reaching production; MIT’s NANDA review of 300-odd deployments found 95% of generative-AI pilots delivered no measurable return. The blockers named most often are evaluation gaps, governance friction, and reliability — nobody checks the output, nobody can prove what happened, and nothing behaves the same way twice. None of that is a failure of the AI models themselves. It is structural, and specific to how those systems are built: the ones that fail have no way of being checked before they act, and keep no account of themselves afterward.
AI++ is my answer to those three. A process is settled in an interview that refuses to move on until the ambiguous terms, the definition of done, and the evidence a finished run must leave behind are all pinned down. An LLM then writes the process in a DSL, as a structure of typed steps — and the writing is not finished until a compiler proves it: every value assigned on every path, every branch of every decision covered, nothing produced that nothing consumes, every check actually looking at the thing it checks. Whatever doesn’t hold goes straight back to the LLM, with the step and the reason, in the vocabulary of the process rather than of the compiler; the LLM revises and the compiler checks again. Only what the LLM cannot resolve reliably reaches a person. You only ever see processes that passed.
At run time, each step gets its own agent at its own reasoning depth, and every step that produces or changes something is judged by a separate evaluator before its result is allowed downstream. A step can open a conversation with a named person and hold for days — through restarts — or work several people in parallel until the ones who have to sign off have signed off. Every prompt, every verdict and the reasoning behind it, and the cost to a fraction of a cent, is written down; the system cannot run without writing it.
The idea underneath is the one Agentic Spec-Driven Development argues for: when an autonomous agent does the work, judgment has to move upfront, out of the review of each result and into the specification the agent works from. That book is the method for people. AI++ is the same method with the part people cannot do reliably — proving a specification complete and consistent before anything acts on it — handed to a compiler. Prose can’t be checked. A structure can.
Spec-as-source goes one level further here. A specification is only complete relative to what a business has already settled, so AI++ holds a company’s standing decisions — approval limits, approved vendors, who is never contacted after hours — checked for contradiction as each one is added, and hands them to the LLM writing every new process. That LLM starts from what the company has already decided rather than from a blank page. So the value doesn’t sit in any single process: each one leaves the company’s decisions more complete than it found them, and each new workflow deploys faster and more easily than the one before.
Rishon and AI++ come out of the same long-held conviction: that what actually executes should be a DSL — not hand-written code, and not free text — because a DSL is the one form a compiler can verify and an LLM can reliably author. Rishon was conceived before agentic systems could be trusted to run a business, so it puts the rigidity in the system — a domain model designed first, workflows driven deterministically, agents started and supervised by it. AI++ is the agentic-first answer to the same conviction, built once the models could carry it, and it moves the rigidity from the system to the verification: agents do the driving, and nothing runs unproven.
AI++ adds a second conviction, and it is the newer one: that with a properly written specification, business process automation needs no engineers at all. That strictness isn’t something each automation has to be engineered for — it is built into AI++ once, and every process it writes inherits it. AI++ builds a custom agentic harness on the fly, from a specification anyone can hold a conversation about.
Built solo: 74 packages, some 96,000 lines of TypeScript and Dart. Live at ai-plusplus.com, taking three engagements at a time. If you deliver automation to clients, or build software that needs a layer for the work that outlives a session, that’s worth a conversation.