# Turnado

> Return BV makes two products under the name Turnado, on one account and one subscription.
>
> **Turnado Ops** is a project board where AI colleagues do the work: an analysis document becomes
> a backlog, agents carry out the work on the board, and people approve along fixed gates.
> Everything that happens is recorded on the ticket — not in a chat history.
>
> **Turnado Storm** is a shared AI workspace: a whole team can be in the same conversation at the
> same time, seeing who is reading which answer, commenting on a specific answer, and each holding
> a role — writer, reviewer, devil's advocate, reading along — that changes what the model writes.
> A conversation is a tree instead of a scroll: branch it anywhere, ask the same question twice and
> compare the answers side by side, see which parts of an answer were guessed, and move the
> assumptions underneath to have the conclusion rewritten. Pages from the project wiki can be
> switched on as sources, and an answer can be written back to that wiki as a draft page. One
> branch becomes an analysis document that goes into the Ops intake.
>
> Both run at https://turnado.eu/.

Facts stated on the site and made true in the code:

- The two products share one account, one credit balance and one set of limits. There is no second
  subscription and no second wallet. Storm is a separate application with its own address and its
  own sign-in screen: nothing of the project board is visible inside it, and nothing of Storm is
  visible inside Ops.
- In Storm every turn knows its parent, so branching, rewinding and comparing are the same
  mechanism rather than three features. The context sent to the model is the chain of ancestors —
  there is no separate rule deciding what the model gets to see.
- A role in a Storm conversation is not a label: it is turned into system prompt, so a reviewer
  makes the model write down what its conclusions rest on and a devil's advocate makes it end with
  the strongest objection to its own answer.
- Turnleaf, the project wiki, connects both ways: a wiki page can be switched on as a source for a
  conversation, and an answer can be written back as a draft page with its origin in the history.
- Choosing between two Storm answers produces a preference pair, the signal used to improve
  models. Whether it may be used is a per-organisation consent setting, off unless switched on.

- The board is the single source of truth. Agents operate it through the same tool contract as
  people do through the buttons; there is no separate "agent mode" with extra permissions.
- Status transitions hang on calculated conditions (acceptance criteria present, CI green, review
  approved, deployed to TEST, human test passed). A condition is a pure function — not a model —
  so an agent cannot write its own green tick.
- There is a list of permissions an agent never gets, however many roles it carries: merging pull
  requests, releasing to production, permanently deleting items, changing the workflow, managing
  members and secrets, and rewriting the audit log, among others. That list lives in code and is
  guarded by tests.
- Turnado does not replace AI coding assistants such as Claude Code, Cursor or GitHub Copilot: the
  code work runs on the model the customer chooses (your own key is possible). Turnado adds what an
  assistant lacks the moment a second person or a second week arrives: a lasting memory, one shared
  board and a process that guards the difference between "the model says it is done" and a tested
  release.
- By default every kind of work — code, heavy process work and routine process work — runs on
  Mistral Medium at a European provider: one model, one bill, one place where the data is. The
  catalogue also holds Claude, GPT and smaller open models, and a project switches any lane over in
  one screen. An organisation can enforce that only EU-hosted models are used; a choice outside that
  is refused with the reason attached.
- Turnado‑1 is not its own weights file. It is our prompts, our tool contract and our yardstick
  running on an open European model. It is stated this way because the alternative quietly becomes
  a lie.
- Every agent run is recorded on the work item with its model, duration and cost; each task has a
  cost ceiling, and usage above the plan allowance is passed on at cost with no mark-up.
- The first project is free; no credit card required. There is no invoicing for usage above the
  allowance yet, and no self-service button to switch plans.

## Pages

- [Turnado](https://turnado.eu/): what it is, how it differs from an AI assistant, and sections for business
  analysts and developers.
- [Pricing](https://turnado.eu/pricing): the first project is free, without a credit card; the plan limits
  are spelled out.
- [Get started](https://turnado.eu/get-started): the steps from account to first board.
- [Documentation](https://turnado.eu/docs): 13 how-to guides.
- [Blog](https://turnado.eu/blog): 13 articles.

## Documentation

- [Quickstart: from an empty account to a board with work on it](https://turnado.eu/docs/quickstart): The shortest route through Turnado: create an account, start an organisation and a project, paste your analysis, and watch a backlog appear on the board.
- [How to turn an analysis document into a backlog](https://turnado.eu/docs/analysis-to-backlog): Paste a functional design or an analysis and an agent decomposes it into epics, features and user stories with acceptance criteria — each one pointing back at the section it came from.
- [How to drive the work from the chat](https://turnado.eu/docs/chat-as-remote-control): The chat is where you say what should happen; the board is where it is recorded. This is what you can ask for, which commands exist, and what lands on a ticket afterwards.
- [How to write acceptance criteria a gate can check](https://turnado.eu/docs/write-acceptance-criteria): Given/When/Then criteria are what turns “the model says it is done” into something a test can disagree with. This is how to write them so the gates and the test agent can use them.
- [How to move a ticket through the gates](https://turnado.eu/docs/move-a-ticket): Nine statuses, sixteen transitions and eighteen conditions. This is how a transition is refused, how to read the reason, and how a question puts an item on Blocked and an answer takes it off again.
- [How to plan a sprint within capacity and AI budget](https://turnado.eu/docs/plan-a-sprint): A sprint in Turnado has two ceilings: the hours your people have and the euros the agents may spend. This is how to compose one, and what to do with the items that fall outside it.
- [How to set up AI colleagues and let them pick up work](https://turnado.eu/docs/set-up-ai-colleagues): Six agents with roles, a queue with slots and a WIP limit, and an autopilot that is off until you turn it on. This is how work reaches an agent, and why some work never does.
- [How to choose a model per kind of work, and keep it in the EU](https://turnado.eu/docs/choose-models): Turnado splits work into three kinds and picks one model per kind. This is how to connect a key, what each kind costs, and how to refuse any model that runs outside the EU.
- [How to keep the AI bill predictable](https://turnado.eu/docs/control-ai-cost): A ceiling per task, a budget per sprint, an allowance per month, and every run recorded on the work item it was made for. This is how to see what AI actually costs you and where it stops.
- [How to connect a Git repository and get pull requests](https://turnado.eu/docs/connect-a-repository): Give the AI colleagues somewhere to write code: a repository, a branch naming rule derived from the work item, and pull requests you review and merge yourself.
- [How to set up delivery and open the release gates](https://turnado.eu/docs/set-up-delivery): A four-step wizard from “where does your pipeline run” to a snippet you paste into it — and after that, gates that open because a pipeline reported, not because someone ticked a box.
- [How to receive Turnado webhooks and verify the signature](https://turnado.eu/docs/webhooks): Subscribe to events, check the signature in Node, Python or C#, and deduplicate on the idempotency key — because delivery is at least once, never exactly once.
- [How to invite people, hand out roles, and know what an agent can never do](https://turnado.eu/docs/team-and-permissions): Roles are cumulative, seats are only for people who decide, and fourteen permissions are on a list no agent ever gets — however many roles you give it.

## Blog

- [Our European vision: sovereignty is a setting, not a sticker](https://turnado.eu/blog/european-ai-sovereignty-in-practice): Why we build an AI delivery platform in Europe, which three things we can point at instead of claiming, and what being European does not excuse us from.
- [Bring your own coding agent: what an ops layer adds to Claude Code, Cursor and Copilot](https://turnado.eu/blog/ops-layer-for-your-ai-coding-tools): Turnado does not plug into your editor. It meets whatever writes your code at the four places that already produce evidence: the ticket, the branch, the pipeline and the model bill.
- [Turnado vs Claude Code, Cursor and Copilot: what changes when a second person joins](https://turnado.eu/blog/turnado-vs-claude-code-cursor-copilot): AI coding assistants are excellent at writing code and were never built to run a delivery process. Here is exactly where the line sits, and why the two are complements rather than competitors.
- [How to write a functional design an AI can decompose](https://turnado.eu/blog/writing-a-functional-design-an-ai-can-decompose): You do not have to write differently for machines — you have to write more precisely, which helps people too. Seven habits that turn a document into a backlog worth editing.
- [Jira and Azure DevOps in the agent era: what a board needs when half the team is AI](https://turnado.eu/blog/jira-azure-devops-in-the-agent-era): Traditional issue trackers assume every actor is a person who can be reasoned with. Four assumptions break when agents do the work, and each one has a concrete fix.
- [Measuring AI autonomy: five metrics that tell you whether your agents actually help](https://turnado.eu/blog/measuring-ai-autonomy): Lines of code and “tasks completed” measure activity, not value. Five metrics that survive contact with reality, and the two vanity numbers to stop reporting.
- [Human in the loop: which decisions must stay with people when agents do the work](https://turnado.eu/blog/human-in-the-loop-decisions): Not every approval deserves a human, and not every human approval is real. A test for deciding which decisions to keep, based on reversibility, accountability and evidence.
- [GEO: how to get your product cited by ChatGPT, Claude and Perplexity](https://turnado.eu/blog/geo-getting-cited-by-chatgpt-and-claude): Generative engine optimisation is not SEO with new keywords. It is making your pages quotable: verifiable facts, answered questions, real URLs per page, and structure a machine can lift.
- [What does an AI coding agent actually cost per user story?](https://turnado.eu/blog/what-does-an-ai-coding-agent-cost): Model usage is the first line item in software delivery that varies per work item. How to budget it, where the cost hides, and the four ceilings worth having before you need them.
- [EU-hosted AI for software teams: what “European” actually has to mean](https://turnado.eu/blog/eu-hosted-ai-for-software-teams): Data residency, the AI Act and GDPR turn a marketing line into a set of concrete questions. Six of them, with the answer that makes a claim checkable instead of reassuring.
- [The eighteen conditions an AI agent should never be able to skip](https://turnado.eu/blog/gates-an-ai-agent-cannot-skip): Guardrails for agentic delivery, concretely: which conditions belong on which transition, why they must be calculated rather than judged, and how to tell a real guarantee from a convention.
- [Vibe coding works alone and breaks in a team — here is exactly where](https://turnado.eu/blog/vibe-coding-in-a-team): Building by conversation is genuinely fast for one person on one project. The three things that break when a colleague, a customer or a second month arrives, and what replaces them.
- [What is AI-native DevOps? A working definition](https://turnado.eu/blog/what-is-ai-native-devops): AI-assisted development makes a developer faster. AI-native delivery puts agents on the board as actors with roles, permissions and a cost. This is the difference, with the five properties that mark the line.