Build log • November 2026
The Building of the Kurultai
Named for the strategist who never took the throne and raised four rulers. Original illustration, not a historical likeness.
The Kurultai is a free AI strategy tool. You tell it what your organization actually does all day and who actually does it, you place yourself on four sliders written in the words executives really use, and a few minutes later it hands back a strategy document: a ceremony audit that sorts your processes into work judged by what it produces and work judged by how it is performed; a decision ledger that turns every freed hour into a choice with a name and a date against it; a people arc; a staffing map; ninety days; and a governance starter.
It will not write your layoff plan. Not at any slider setting, not if you ask it directly, not if you insist. That is the whole product, and this is a log of what it took to make that sentence true in code rather than true in a press release.
A promise is not a feature until it is enforced
Anyone can put "we don't do layoffs" in a system prompt. The question is what happens on the day the model does it anyway, because a model that has been asked for a staffing reduction schedule by a buyer who sounds authoritative will sometimes produce one.
So the rule is enforced three times. The engine's own instructions are the first line, and in testing they have never failed. A separate check reads the finished draft before anyone sees it and stops anything that advocates fewer people. And a third reader — a small, cheap model asked one question and nothing else — reads it again.
The distinction that took longest to get right is the one between naming and advocating. The document is required to tell a buyer who asked for a layoff plan that it will not write one. An early version of the guard policed the mention rather than the recommendation, which meant it killed the document for containing its own refusal. It also, on one memorable run, killed a grant fund's document twice because the fund's initials were RIF.
Over-flagging is not the safer failure. That is the sentence the whole guard is built around.
What the rails actually catch
The middle layer is a word-pattern check, and it is honest about its limits: against five phrasings taken from a deliberately hostile test — passive voice, numerals as arrows, euphemism, and a refusal with a recommendation hiding behind it — it catches none of them. It is a backstop, not a rail, and the test suite prints that score on every run so nobody can mistake it for complete.
The third reader catches all five. It was also measured against seven passages it must not flag, and that half matters just as much. It took two rounds of tuning, and both failures are worth keeping because they are the shape of the line:
- It missed "operate the desk with fewer adjusters" — real advocacy, with no number and without the word headcount.
- It flagged "cut analyst time on the close by half, and the analysts keep the hours as MyWork" — which is the most ordinary correct sentence this product writes. The verb beat the subject.
The instruction now reads: when something is being reduced, read what is being reduced, never the word doing the reducing. Cutting hours is not cutting a person. Twelve of twelve, both halves.
Four faults found by reading, not by testing
At one point the test suite was green on 164 checks while four faults sat on every document the tool had ever produced. All four were obvious to anyone who read a finished document start to finish. None were visible to a single assertion, because assertions test structure and these were faults in writing.
A sentence had lost its subject. A database value was printing raw in a table cell, on a page that defined that very word as a term two sections later. An acronym had been lowercased into something that looked like a typo. And the engine was pointing at "the ledger above" when the ledger renders below — a model writes fields, and does not control the order they are laid out in, so one of those was always going to be wrong on the page.
Three of the four existed only in the rendered page and nowhere in the data. So the proofreader that now guards against them reads the page, not the output.
The part worth telling
The third reader shipped, the tests passed, and the document came back clean. It would have been easy to call that done.
It was not done. The reader was calling the wrong method — one that returns a response without the parsed result attached — so it ran on every document, cost a fraction of a cent each time, found nothing, and reported nothing. The safety layer was decorative. It had been live for about an hour.
It passed review because the test written for it made the same wrong assumption as the code it was testing. Eleven checks went green over a reader that could not possibly work.
Then it happened again one level up. The check whose entire job was to confirm the fix had reached production reported everything fine — because it tested that the file was present, not that it worked.
Three faults, one shape: a test written from the same misunderstanding as the code tests nothing. What caught all three was not a better test. It was running the real thing against production and reading what actually came back — and, the first time, noticing what was missing from the logs rather than what was in them.
Receipts
Two days from empty repository to live tool, built at one desk. The engine is a Lambda behind an API gateway with its key in a parameter store; a document takes minutes to write and a gateway request is capped at thirty seconds, so the request books a job and the work happens in a second, asynchronous invocation while the page waits. Logs record the shape of a failure and never its content, because an API error can quote the buyer's own sentence straight into a log that outlives the two hours the finished document is kept.
The test suite stands at 185 checks, including ones that read the deployed bundle rather than the repository — because a deploy is a separate act from a commit, and the code that is right in version control can be a day behind the code that is serving people, with nothing on screen to notice.
Every rail in it was broken on purpose and watched fail before it was trusted.
The tool is free, needs no account, and keeps nothing but a count and your finished document, which deletes itself within two hours. There is a complete sample document if you would rather read one than make one, and a library of editions reading real organizations from their own public filings and nothing else.