% 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 it structurally sound before it is allowed to run. Every step that produces or changes something is judged 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. 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.
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 there for hours or weeks, surviving 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.
Agentic Spec-Driven Development makes the argument this rests on: 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. The book is that method for people. AI++ is the same method executed by machine. The part people cannot do reliably — proving a specification complete and consistent before anything acts on it — is handed to a compiler. Prose can’t be checked. A structure can.
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 — checks each new one against the ones already there, and embeds them in every process the LLM writes. Nobody restates them, and nothing has to be designed around them. So building a process here is not an engineering project: the part a developer would normally encode already exists. That holds for the first process as much as the fiftieth, and what accumulates over time is the specification, not a discount. Spec-driven development usually produces a document per project, written and then abandoned. Here it belongs to the company, and outlives everything built from it.
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, newer conviction: 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.