Practical prompting, backed by research

Asking a model "are you sure you're right?" is like asking a student right before an exam: same head, same context, same answer. Plain self-critique gave little signal in the paper. PVD gives you a signal of whether to trust an AI's answer — tested on graduate-level science questions; using it for law, medicine or finance is our extrapolation. The trick: one role defends the answer with 3–5 atomic, checkable claims, and the other attacks the weakest of them. If after several rounds the answer hasn't changed, that's ANC (accepted + no change): a signal that the answer held up under pressure.

Between 56% and 85% of the facts found are lost when a task is handed off between AI agents, and that's not a bug but a systematic pattern. A structured handoff protocol lets you preserve risks and exculpatory details when a task is split across several chats or stages. The catch is that the model writing the summary decides on its own what matters, and decides wrong. The method replaces free-form retelling with a mandatory checklist of categories: risk, justification, uncertainty. The model no longer decides what to keep, it just lists, and losses drop from 85% to nearly zero.

Two AI agents are supposed to argue with each other, but in practice they just agree — even when one of them is right. In one test, the critic raised a real problem in the code, the reviewer brushed it off with a confident empty phrase without a single reference to the code — and the critic backed down. The Adversarial Review method forces the critic to choose one of three options: agree, cite evidence of disagreement, or raise a question without a citation — and then the reviewer must either confirm the concern with its own citation or drop it. This gives you a real, evidence-based check of code, text, or a contract instead of a polite "looks fine."

LLMs are bad at balancing precision and recall at the same time. Ask them to 'find everything relevant' and you get 50 passages, half of them junk. Ask for 'exact matches only' and they skip important connections. The PRISM method lets you retrieve information with a balance of precision and recall for questions that require combining facts from different sources. It splits conflicting goals across three agents: the Question Analyzer breaks the question into sub-questions, the Selector cuts hard (maximum precision), the Adder brings back what was missed (maximum recall). After 2-3 iterations of the Selector ⇔ Adder loop you get a compact evidence set — everything you need, nothing you don't.

The paradox: the more convincing the final consensus of a multi-agent debate, the fewer concrete facts are left in it. Fact anchoring lets you run a multi-sided discussion and get an honest conclusion, not a nice agreement about nothing. Give each agent a list of concrete facts and forbid backing down without a counter-argument, and the model can't quietly drop inconvenient details for the sake of a smooth ending. In normal mode, up to 72% of the key data disappears; a final audit step makes the losses visible.

The problem: an LLM agent takes 15 steps on a complex task and messes up on step 7, and you only find out once it has "finished" everything. All that work, wasted. Magentic-UI lets you insert yourself into the process at every meaningful step: first you ask for a plan and edit it, then the agent moves forward but stops at the right points and waits for your approval. The shift: you don't write one giant prompt hoping for a miracle; you take on the role of project manager, and the LLM becomes a contractor who reports back at key stages. The interaction stops being a lottery.

65% of real people's arguments in NYT debates are unique: nobody else repeats them. For LLMs in default mode, only 3.4% are unique. Not because the model is dumb. Because it's trained to give "an answer for everyone": safe, balanced, offends no one. Diversified prompting gets you fundamentally different positions on a contested issue instead of yet another rehash of two or three obvious points: an explicit diversity instruction + a ban on repetition + a requirement for specific examples raise coverage to 50-55% of the human range of arguments.

A model loses track of criterion independence when you score 5+ dimensions in one prompt. You get the halo effect: a high empathy score drags the ethics score up, even though they're different things. The Multi-Agent Framework lets you accurately score complex subjective criteria (pitches, essays, interviews) by splitting the task. The trick: instead of one prompt saying "rate on 9 criteria," you run a text cleanup + 9 separate agents. Each agent gets 3 examples for fine calibration (low/medium/high score) and scores only its own criterion. Agents never see each other's scores, so the criteria don't interfere with each other.

Two virtual agents arguing inside a single prompt deliver +7.95% accuracy while saving 58% of tokens vs 5-7 API calls. INoT gives you deep logic checking through an internal debate instead of expensive external iterations (as in CoT or IoT). Pseudocode sets a strict loop: argument → critique → rebuttal → adjustment. The LLM follows this structure like a program, writing from the perspective of two opponents. Consensus within 10 rounds instead of 7 calls to the model.

Five different personas in a prompt almost always deliver the same verdict: the LLM simply fits its justification to the 'you're a skeptic' label. The ESPP method lets you get genuinely different, well-grounded opinions from 'user types' in a single chat, with no focus groups and no code. The fix is simple: before scoring, each persona answers questions about its past experience; that's its memory, and the score must not contradict it. The trick: it's not the character description that keeps the model in check, but facts on the record — a label is easy to work around, your own words from earlier in the conversation are not.

A real team proposes an idea, starts building on it, and gets stuck. Every option after that turns out to be a variation on the same theme: different words, same substance. An LLM with the right structure doesn't get stuck, and in the experiment it beat live teams on idea novelty by a factor of two. The method lets you get several concepts from fundamentally different areas in a single request, instead of a cluster of look-alike options. The trick: each round, one agent leaps into a new domain and the other picks the stronger of the new and the old. Not developing one thought, but a forced sweep of the space: wide search plus a filter. Three rounds, three leaps, one final idea.

A model easily catches contradictions — and is completely blind to what isn't in the text. That's exactly what half-truths feed on. RADAR lets you find omissions in any claim: a pitch, a press release, a statement — anywhere every fact is true but the picture is deliberately incomplete. The key shift: instead of a pro/con debate, one agent builds a narrative from the facts, while the other attacks not the facts themselves but the gaps in the narrative. These are different tasks, and the model generates fundamentally different answers.

LLMs are catastrophically bad at finding errors in their own conclusions. Once the model has generated a solution, it defends it, even if there's a mistake in step two. This is called anchoring: generation creates an attachment, and critical thinking switches off. DiMo gives you multi-level verification from one and the same model, as if a team of four were on the job. The trick: you don't try to make the model check itself; you split the work into roles via separate prompts. The Generator produces an answer, the Evaluator hunts for holes (it doesn't generate!), the Refiner makes surgical fixes (it doesn't rewrite everything!), the Judger makes the call. On math, Logical mode delivers 90.7% accuracy: the model finds the error in step 2 and recalculates instead of dragging the mistake all the way to the end.

The paradox: The more context you give a model, the worse it performs. Feed it the question + a big table at once and the model "forgets" parts of the question. A multi-hop request ("calculate X, then compare with Y") turns into an answer about X only. TabDSR lets you get accurate answers to complex questions about tables, especially when you need several calculation steps and the data is dirty ($3,275, "N/A", notes in parentheses). The method's trick: it splits the process into three independent steps. The decomposer breaks the question into sub-questions (it works ONLY with the question text and ignores the table). The sanitizer cleans the junk out of the table (currency symbols, percent signs, footnotes). The reasoner generates Python code for each sub-question. Each step covers a separate LLM weakness instead of trying to do everything in one prompt.

Everyone worries the model will make something up. The real threat is different: 44–60% of genuinely dangerous answers aren't lies but silence about something important. The model just didn't mention a necessary step, didn't add a needed option, didn't hedge. LLM Council lets you catch these gaps — with a panel of 4 independent experts in one chat. The trick: each one comes at the task from their own angle. The CFO looks at the numbers. The litigator — at what you can't prove in court. The tax advisor — at what will blow up a year from now. What one misses, another will catch.

The problem: LLMs lean on stereotypes precisely where there's no clear-cut answer. When choosing a candidate for a role, the model relies on memorized prejudices in 75-85% of cases instead of an honest "unknown". MPT lets you make decisions in ambiguous situations (hiring, evaluating ideas, conflicts) while reducing the influence of stereotypes by 36%. The model reasons from three personas: two opposing ones (young/experienced) + a neutral one. Several rounds of mutual critique make stereotypes explicit. The final step drops the personas: the model acts as a judge and picks the logical conclusion, instead of following the majority or a single perspective.

Same model, same chat, but the second request is written as an equal colleague, not a boss. Sounds trivial. Yet that's exactly what works best. The method lets you simulate two independent experts in a regular chat, with no extra tools or fine-tuning. The trick is the balance of power: the "teacher → student" setup loses to "peer ↔ peer". An equal has no need to agree out of politeness, so the model starts genuinely critiquing instead of rubber-stamping.