PAWNI: turns your questions into a structured prompt through a dialogue with eight AI agents

STEP 1: Task classification → simple (skipped) or complex (moves forward)
STEP 2: Classifier agent extracts the core request, identifies the domain → clean task statement
STEP 3: Knowledge agent pulls in best practices for that domain → pattern library
STEP 4: Interviewer agent asks questions across 18 items (must-answer ones are mandatory, the rest can be skipped) → filled-in prompt structure
STEP 5: Draft agent assembles the prompt from your answers → draft prompt
STEP 6: Verification loop — the system generates an "ideal answer" to the draft, cross-checks it against the original requirements using several LLM judges → final prompt

All these steps happen inside one system (in the original paper — code running eight agents), but you can replicate the logic manually with a single instruction prompt in a regular chat.

Task: You're an entrepreneur who wants ChatGPT to build a launch strategy for your coffee brand on Amazon and Etsy — a complex, multi-part task loaded with hidden variables (budget, timeline, competitors, product lineup).

Prompt:

Before you answer, run a short interview with me to gather a complete prompt for this task. Don't answer the task itself yet — first ask clarifying questions in the categories below, if I haven't already specified them:

MUST clarify (can't move forward without these):
- Role: what role should you play (marketer, strategist, etc.)
- Context: what I already know, what I've already tried, what the current situation is
- Goal: what success looks like for me
- Task: exactly what needs to be done, are there subtasks
- Input format: what I'll be giving you (description, numbers, files)
- Output format: what the result should look like (list, table, document)
- Final deliverable: the exact artifact I should get at the end
- Constraints: what's off-limits, what boundaries exist (budget, timeline, ethics)

SHOULD clarify (if I don't answer, make a reasonable assumption):
- Examples: any references or similar cases
- Style and tone: how to write (formal, friendly, etc.)
- Audience: who will read the result
- Reasoning depth: should you spell out your thinking step by step
- Formatting rules: headers, tables, visuals
- Task-specific quirks: anything unique to this type of task

Ask one block of questions at a time, wait for my answer, then move to the next block. Once you have everything — give me the full final prompt, then answer it.

My task: build a launch strategy for my coffee brand on marketplaces like Amazon and Etsy.

Result: The model starts asking you questions in blocks — first about role and context (what's your current revenue, which marketplaces you've already tried), then about goals and constraints (budget, timeline), and so on. After 4-6 message exchanges, you get a coherent, detailed prompt with every piece filled in — and a full-fledged strategy right away, no "no, that's not what I meant" on message number five.

The model is great at generating an answer to any request — even an incomplete one. The problem is that when context is missing, it fills in the gaps itself, meaning it hallucinates requirements you never mentioned. And in a multi-turn conversation, every one of those hallucinations turns into a "fact" the model keeps building on — errors pile up.

At the same time, an LLM is genuinely good at asking relevant questions if you ask it to — it's the same text generation, just a different pattern. PAWNI leverages this: it forces the model to ask before it answers, and structures those questions around a checklist that covers the classic prompt "blind spots" (role, format, constraints).

Levers you can pull: - The list of items to clarify → trim it down for simpler tasks (3-4 items instead of 8) to save time in the dialogue - "Ask one block at a time, wait for an answer" → remove this if you'd rather get all the questions at once as a single list - The final check (generate an ideal answer and compare) → add the line "before answering, check your plan against my requirements and show it to me for approval"

Before doing the task, run an interview with me to gather a complete prompt. Don't answer right away — first ask clarifying questions in the categories below, if I haven't already provided that information myself.

MUST clarify:
- Role: what role should you play
- Context: what I already know, what's been done before
- Goal: what a successful result looks like
- Task: specific actions and subtasks
- Input format: what I'll be giving you
- Output format: how to present the result
- Final deliverable: the exact artifact you'll produce
- Constraints: boundaries, restrictions, requirements

SHOULD clarify (if I don't answer, make a reasonable assumption):
- Examples/references
- Style and tone
- Target audience
- Whether step-by-step reasoning is needed
- Formatting rules (structure, visuals)

Ask one block of questions at a time, wait for my answer. Once you've gathered everything — show me the full final prompt, then do the task.

My task: {task description}

Swap in any complex task for {task description} — from a business plan to a course curriculum.

🚀 Quick start — paste this into your chat:

Here's the PAWNI clarifying-questions template. Adapt it to my task: {your task}.
Ask questions to fill in the fields.

[paste the template above]

The LLM will ask about the missing task details — role, context, constraints — because without them it simply can't build a correct prompt on its own. It'll take the question structure from the template and adapt it to your specific domain.

⚠️ Not needed for simple tasks: if the question is short and factual ("when's the sales-tax filing deadline"), a clarification dialogue is just wasted time. The method only pays off on multi-part tasks loaded with hidden conditions.

⚠️ Requires patience: the method turns one request into a multi-message dialogue. If you need a fast answer right now, this isn't your use case.

⚠️ The study is very small: tested on just 4 participants. The authors themselves state outright that the results don't generalize — this is more a proof of concept than a proven fact.

⚠️ Doesn't cover your own blind spots: if you personally don't know the answer to "what's the budget constraint," the method won't magically supply the missing knowledge — it asks you for it rather than making something up.

The researchers recruited just 4 participants and gave each of them 4 different complex tasks — some tackled with a plain LLM chat, some through PAWNI. To measure not just "which result felt better" but actual mental workload, they hooked participants up to a 32-channel EEG (measuring brain electrical activity) and used the NASA-TLX questionnaire (a standard test for subjective task fatigue).

Result: with PAWNI, all four participants got prompts that were structurally more complete (filling in 42% to 91% of the needed elements, versus clearly fewer without the system), rated the outcomes higher across every quality dimension, and felt less exhausted (workload dropped from an average of 39.6 to 21.7 on the NASA-TLX scale). The most striking number: every single participant reached a solid result in just one turn of dialogue with the model — versus anywhere from one to twelve turns without the system.

Why this matters: the authors are upfront that with only 4 participants, any numbers here are statistically shaky — this isn't proof, it's a signal that says "worth testing on a bigger group." But the direction of the effect was the same for all four participants — and that consistency, not the raw numbers, is the real takeaway: the pattern held for every single subject.

PAWNI (Prompt Architecture Wizard using Neural Intelligence). B. Sankar, Pawni Yadav, Srinidhi Ranjini Girish, Amogh A S — Indian Institute of Science (IISc), Bangalore, India.