How your AI asks you to decide — without taking the decision away from you

By Elad Diamant·Published July 12, 2026

There are two ways for an AI to handle a decision it can't make alone, and both are bad. It can guess — pick the authentication method, the retention window, the rollout order — and hand you a confident draft built on an assumption you never saw. Or it can stop and dump a wall of questions in the chat, and now the work of deciding is and the work of parsing its interrogation is on you.

Inside a PassbackAI document there's a third way. Your AI embeds a small decision widget exactly where the fork is — and the whole design of those widgets is built around one line: it leans, you decide.

Each widget is a verb, not a form field

The palette isn't a big questionnaire with different question types. It's a set of primitives, and each one is a verb — the thing the AI actually needs you to do at this exact point in the draft:

• Choose one — single-choice, when the paths are mutually exclusive (2–4 options).
• Choose many — multi-choice, when more than one can genuinely apply: which fields to collect, which locales at launch (2–6 options).
• Write — open-question, when the point is genuinely open and no list would be honest: a date, a name, a constraint from legal.
• Order — prioritize, a short list you drag into rank; top ships first.
• Group — questionnaire, the one primitive that batches several tightly related questions into a single unit.

The discipline is one primitive per decision. A lone open question doesn't get wrapped in a questionnaire — it travels as its own open-question block with the sentence that raised it right above. The questionnaire is the group tool, reached for only when three or more questions truly form one cluster, not the default vessel for every ambiguity. (And the family is deliberately narrow: quiz, poll, survey, form, multiple-choice, rank — none of those render. The renderer knows five tags, and inventing a sixth just prints dead text.)

But the palette isn't the interesting part. Five widgets is a menu; anyone can list a menu. What makes this feel like an assistant rather than an intake form is a handful of small, deliberate choices about how each widget behaves when you actually sit down to answer it. Those are the rest of this piece.

1. "Recommended" is an anchor that leans — and stops there

Your AI usually has an opinion. It read the brief; magic link really is the lightest thing to ship. The temptation is to encode that opinion as a default — pre-tick the box, and let you rubber-stamp it. That's the move that quietly takes the decision away from you: a pre-selected option is a decision already made, wearing the costume of a question.

So the widget won't let it. The AI can badge one option Recommended, but the badge is mark-only: it never pre-selects, and it's never echoed back into your answers. You still arrive at an unanswered question and you still have to choose. The lean is visible; the deciding is yours.

```single-choice
{ "version": "1",
  "question": "Which auth method ships in v1?",
  "context": "The brief hedged here — magic link is the lightest to build, but room + PIN needs no email.",
  "options": ["Magic link", "Room number + PIN"],
  "recommended": "Magic link" }
```

Two details are doing quiet work. First, the badge has to point at a real option — verbatim — or it's silently dropped, so a stray recommendation can't misfire. Second, and more important: the why doesn't live on the badge. It lives on a separate context line. The badge says where the AI leans; the context says why. Splitting them means you can weigh the reasoning and disagree with it, instead of being handed a conclusion with the argument baked invisibly inside. On a multi choice the same rule holds, only the AI can badge several options at once — it passes an array of labels, and still pre-selects nothing.

2. You are never caged in the AI's list

The second humane default fixes the oldest failure of every multiple-choice box: what if the right answer isn't one of the four? A closed list quietly asserts that the AI's options are the whole world. They never are.

So every question that offers options grows an Other row automatically — the AI doesn't author it, and it can't forget to. You always have an escape hatch into free text. And getting there is one tap: a small pencil on the question drops you straight into that Other row — the "edit-into-Other" gesture — so answering off-menu costs a second, not a hunt. The list is an offer, never a cage.

When a point has no sensible options at all — a launch date, a legal constraint, a name — the AI shouldn't fake a list to look tidy. It reaches for open-question instead: a plain field where you write, with an optional placeholder showing the shape of a good answer.

```open-question
{ "version": "1",
  "question": "What's the data-retention constraint from legal?",
  "placeholder": "e.g. delete 30 days after checkout" }
```

3. A note is a valid answer — sometimes the truest one

Real decisions are rarely a clean pick. Often the honest answer is "B, but only if procurement signs off," or "none of these — here's what's actually blocking it." A widget that only accepts a selection forces that nuance to evaporate.

So every option-bearing question also carries a Note field, always — and a note on its own counts as a complete answer. You can select nothing and just explain, and the AI receives the explanation as your response to that exact question. This is the release valve that keeps the widgets from flattening you: when the truth doesn't fit a radio button, you write the truth, and it still lands anchored to the question that asked it. Answering by explaining is answering.

4. The one line that makes a question answerable: context

A question ripped out of its source is noise. "Which storage tier?" — asked cold, it's an ambush. "Which storage tier? — the brief says privacy should match Markdown mode but never picked a tier" is a question you can actually answer.

That one-line context the AI attaches under a question is the smallest feature with the biggest trust payoff. It names why this is open — where in the source the decision was left hanging, what's genuinely undecided. It does two things at once: it lets you answer well instead of guessing what's being asked, and it proves the AI isn't asking to offload work onto you — it's asking because the source really left a hole here. A question that shows its reason reads as respect, not interrogation.

5. Prioritize always reports back — including "I didn't change a thing"

Ranking has a subtle trap the other widgets don't. Say the AI proposes a rollout order — EU, US, APAC — and you look it over and agree. You change nothing. What does the AI hear?

```prioritize
{ "version": "1",
  "items": [
    { "id": "eu", "label": "EU", "context": "largest waitlist" },
    { "id": "us", "label": "US", "context": "highest revenue per seat" },
    { "id": "apac", "label": "APAC", "context": "needs localization first" }
  ] }
```

In a questionnaire, a question you skip is simply omitted from what goes back — silence means nothing was answered. Prioritize deliberately does the opposite. It always reports the resolved order, tagged with whether you reordered it or kept the order unchanged. Leaving the suggested order untouched is not silence; it's an active endorsement, and the AI reads it as one.

That distinction matters more than it looks. "The user didn't respond" and "the user looked at my proposed order and signed off on it" are opposite signals, and a lazier design would collapse them into the same non-event. Preserving the difference means the AI can tell agreement from absence — so it can proceed on your endorsement instead of nervously re-asking, or nudging you toward a change you didn't want to make.

It's a living document, not a form

Step back and the pattern is clear: none of this behaves like a survey. A survey is a wall of fields you march through, detached from any context. A PassbackAI document is prose with widgets woven into it — each one placed at the exact sentence where the decision arises, set up by the paragraph before it. You read two lines of the plan, and right where the plan forks, there's the fork: two options, one click. You keep reading. The paragraph about regions ends in a list you drag into order.

And the prose itself is a response channel. Settled thinking stays as text — but "settled" doesn't mean "read-only." You can pin a note to any sentence of it, the same anchored comment you'd leave on any pasted draft. So the document is simultaneously the context and the intake for its own open questions. Reading the draft and resolving its unknowns become one pass, not two.

A few smaller things fall out of that design, worth knowing:

• You can mix freely. One document can hold a single choice, a ranking, an open question, and three paragraphs of prose — each widget renders independently, in place, in reading order.
• Right-to-left is automatic. There's no language or direction field to set. Direction is detected from the content, so a question written in a right-to-left script — Hebrew, Arabic, Persian — renders mirrored on its own, from the very same widget JSON. Nothing about the syntax changes; only the layout follows the text.
• The palette is open and growing. Today it's five widgets; the family is built to add more as new verbs, additively, without disturbing the ones above. On the roadmap: verify (confirm or correct a claim), suggested-change (accept, reject, or edit a rewrite), and tradeoff/scale (a slider on a spectrum). Same ethic each time — a new way to lean a decision toward you without taking it.

What happens to your answers

You fill the document in, and at the bottom you hit Copy. You get a tidy Markdown bundle — one stanza per answered question, your picks and notes underneath, the resolved priority order tagged with whether you moved it — and you paste that back into the chat where the draft came from. Your AI reads every decision, anchored to the question that asked it, in one round-trip. When you paste a document into passbackai.com and answer it, nothing you paste is uploaded; the whole exchange happens in your browser.

One nice shortcut if your AI is connected to PassbackAI over MCP: it can route the document to you and read your answers back itself, so the last step stops being "copy, then paste" and becomes just "send." Same widgets, same humane behaviors, same JSON underneath — the only difference is who carries the answers home. (That routed path is stored on our server so your AI can read the responses; the plain paste path stays in your browser.) Nice to have, but not the point. The point is everything above: a document that asks you for a decision, and is carefully built never to make it for you.

The best assistant isn't the one with no opinion, and it isn't the one that decides behind your back. It's the one that says "here's where I'd go, and here's why" — and then hands you the pen. That's what these widgets are for.