Caliper is built for desktop screens. It works here, but its editors and results need room.
// Private for now
Sign in to continue
Crucible, The Matrix, Forge, The Quarry and The Anvil are private while they are being finished. Only the owner's Google account can open them. The home page and the About page are open to everyone.
> SYSTEM INTENT An integrated engineering suite designed to strip speculative hype from Generative AI. Enforce financial rigor, stress-test logic boundaries, and forge hardened assets for surviving use cases.
// The assembly line
Use any module on its own, or next to the tools you already have. In this order, they take an AI idea from a first cost check to a tested system.
Subject LLM logic to extreme edge-case pressure to map failure states prior to production.
// Operational boundaries
01. No black boxes
Every output requires a measurable input. Scoring is deterministic math and logic, with no AI evaluating AI. The one exception, The Anvil's judge, is a model you choose, with a fixed, visible share of the score.
02. Financial reality
Token economics are not an afterthought. If the compute token burn and maintenance overhead exceed the manual labor saved, the system kills it.
03. Structural integrity
AI is treated as unverified software. No trust is granted without adversarial validation.
The maker
> BUILT BY Shashikant Jha, Conversational AI Architect. 9+ years taking chatbot, voicebot, GenAI and agentic AI solutions from concept to production. Precise enough to scale, human enough to stick.
Say what the prompt must do, in your own words. It is saved with the prompt in your library, so whoever rewrites the prompt later, a person or an AI, keeps its purpose, and the test messages show if the rewrite still works. Forge's grade does not use this text.
Build a prompt from valid pieces: every choice comes from the engine's grammar, and the live check on the right scores the result with the same engine as the editor. When it looks right, press Generate & Edit.
1. Persona
Who the AI is. Written under # Role.
2. Names
Agents, variables, and tools your rules refer to. Written under # Agent Registry, # Tools, and # Variables.
3. Rules
One command per rule. Written under # Rules; a condition becomes an IF … THEN: block with the rule indented under it.
Compare the prompts of two or more agents that work together. You see how alike they are, every difference marked side by side, and the conflicts: places where one agent is told to do something another agent is told never to do. Add each agent's prompt below; the results update as you type.
Getting Started
Write prompts that an AI follows the same way every time. No technical background needed.
You're reading the Beginner guide. When the words here feel familiar, switch to at the top of the page.
What this tool does
An AI follows your prompt word for word, and fills every gap with a guess. This tool reads your prompt like a strict reviewer. It points out where the AI would have to guess, where two instructions clash, and where the wording is too soft to be followed reliably.
Nothing you type leaves your computer.
Your first five minutes
Paste your prompt into the big box on the left, or start from our example.
Look at the grade in the square. A is great. F means something must be fixed.
Open Issues and fix the first item, or Top fixes for the changes worth the most points. The grade updates as you type.
Click any line number, like L12, to jump to that line. A line with something to fix shows ✕, ! or i beside its number in the editor: click it to read what's wrong right there.
Repeat until you're happy. Undo appears in the toolbar if you change your mind.
Five habits of a reliable prompt
1. Tell the AI who it is
Start with one line that sets its role. Everything else is read from that point of view.
✓ You are a friendly billing support assistant.
2. One instruction per line
Start each instruction with You MUST or You NEVER. Two actions in one line are hard to check.
✗ You must check the account and send a summary.
✓ You MUST check the account. ✓ You MUST send a summary.
3. Ask for things you could check
If you couldn't tick a box by reading the AI's reply, the AI can't reliably follow it either.
✗ Be concise.
✓ You MUST answer in at most 3 sentences.
4. Don't contradict yourself
Long prompts often say one thing on line 5 and the opposite on line 50. The AI picks one at random.
✗ You MUST share the price. … You NEVER share the price.
✓ IF the user is a customer THEN You MUST share the price.
5. Define names before you use them
If your rules mention a helper or a fact by name, define it once near the top.
✓ - 'billing_agent': agent that handles refunds. ✓ - 'is_vip' is boolean.
Reading your results
Colors
Red: must fix Two instructions clash, a number limit is unreadable, or a secret is exposed. Any red item drops the grade to F and the score to 49 or less, and empties the bar of the check it belongs to.
Yellow: should fix The AI may guess or skip something. These lower your score.
Blue: tips Small improvements, like spacing or soft wording.
The eight checks behind the grade
Check
What it asks
Can it be checked?
Does each instruction ask for something you could see in the reply?
Firm wording
Do instructions use MUST and NEVER rather than "should" or "try to"?
Talks to the AI directly
Are instructions written as "You MUST …", so it's clear who acts?
No contradictions
Do any instructions clash? Is every name defined?
Tidy layout
Are sections and spacing neat?
Spelling & typing
Any typos, repeated words, or odd characters?
No secrets leaked
Is a password or secret key pasted in?
Says it plainly
Does it read like plain instructions, or like AI-written text (long dashes, buzzwords, hype words, "not X, but Y" lines)?
Word cheat sheet
Firm: use theseMUST, NEVER, ALWAYS, DO NOT
Soft: only for true preferencesshould, may, prefer
Weak: remove themtry to, if possible, maybe, ideally, hopefully
Vague: replace with specificsappropriate, relevant, properly, as needed, etc.
"How often" words: use IF … THEN insteadsometimes, usually, rarely
AI-sounding: say it plainly long dashes (—), you are not X, you are Y, elite, seamless, delve, feel free to
Instructions that depend on a situation
Use IF (or WHEN) for the situation, then THEN for what to do:
IF the user is angry THEN You MUST apologize once.
WHEN the user asks about a refund THEN You MUST transfer the chat to 'billing_agent'.
Without THEN, the AI knows the situation but not what to do.
Naming helpers and facts
Put names in quotes at the start of a line, under a heading. Then use the same spelling everywhere.
# Agent Registry
- 'billing_agent': agent that handles invoices and refunds.
- 'tech_agent': agent that handles login problems.
# Variables
- 'is_vip' is boolean.
- 'order_total' is number.
The Names tab lists everything you defined. If a rule uses a name you forgot to define, you'll see Name used but never defined.
The tabs on the right
Issues: everything found, with how to fix it. "Show technical detail" reveals the engine's own wording.
Top fixes: the changes that raise your grade most, in order.
Instructions: every line read as an instruction, marked clear, hard to check, or not an instruction yet.
Names: the helpers and facts your prompt defines.
Checks: the eight checks behind the grade, each with its bar. Any check below 100 also shows under the grade.
Target models
In Settings → Target models, tick the models you write for. Lines that a model is known to read differently get a note, for example stacked emphasis (CRITICAL: You absolutely MUST) that makes newer models over-apply a rule. Each note links to the vendor's guide it comes from and the date it was checked.
Notes never change the score or the grade. With nothing ticked, no notes show. A fine-tuned open-weight model uses its base model's entry; a model that isn't listed has no notes.
Several agents that work together
When two or more AI agents share the same customers, their prompts must agree. Open Compare (next to Builder) and paste each agent's prompt into its own card. Compare shows:
How alike they are: 100% means the same rules, 0% means nothing in common.
Opposite instructions: one agent must do something another must never do. Fix these first.
Other differences: one rule is firmer, a limit or a condition differs, copied text no longer matches, a name means different things, or an agent hands over to an agent that is not there.
Hand-overs: a map of who passes the conversation to whom. It warns when an agent needs something no agent gives it, gets work it must never do, or when agents pass a customer round in circles.
Side by side: two agents' rules lined up, with the changed words marked.
If a difference is on purpose, press Mark as intended. It stays hidden until its text changes.
✗ Billing: You MUST share the full account number. · Front desk: You NEVER share the account number.
✓ Both: You NEVER share the full account number.
Ready for the next level?
Once you know these habits, switch to . You'll see the same issues with their technical names alongside the plain explanation. That makes it easier to discuss prompts with engineers.
Reading the Engine's Language
Every technical message, translated. Use this to understand results and to talk with engineers about them.
You're reading the Intermediate guide. New to this? . Want the full technical reference? .
1. How messages look at this level
Each finding shows three things:
The technical code, like undeclared-entity. Engineers and the exported file use this name.
The engine's original message, word for word.
In plain words, with a one-line Fix.
2. Vocabulary bridge
Beginner wording
Technical term
Meaning
Instruction
Rule, directive
A line that tells the AI to do or not do something.
Command word
Modal
MUST, NEVER, SHOULD, MAY, DO NOT.
Firm / soft wording
Hard / soft constraint
MUST and NEVER are hard. SHOULD and MAY are soft.
Action word
Verb (catalog)
The word after the modal, like send or ask. It must be in the engine's catalog to be checked.
Can it be checked?
Enforceability
Share of instructions that are actionable, measurable, and provable.
Hard to check
Unprovable
Firm, but shaped so it can't be verified: two actions, an unknown verb, a malformed number limit, or a before/after/until part that isn't an action.
Too vague to check
Unmeasurable
Nothing observable in the reply, like "be concise".
Not an instruction yet
Unparsed
Reads like a rule but has no modal or no recognized verb.
Firm wording
Hardness
Average strength of the command words used.
Talks to the AI directly
Directness
Imperative, second-person instructions. Each passive line (voice/passive) counts half.
No contradictions
Consistency
No proven conflicts and no undeclared names.
Says it plainly
Literalness
No phrasing typical of AI-generated text. Each literal/* warning costs a fixed number of points.
Defined name
Entity, declaration
A quoted name or pointer at the start of a top-level line, followed by is or :.
Helper
Agent
An entity another conversation can be routed to.
Fact that can change
Variable
An entity with a value: boolean, number, one of, or text.
Sets a value
Assignment
IF … THEN 'x' is true. It changes a variable at run time; it never defines one.
Situation
Condition
The IF / WHEN … THEN part. A condition line ending in THEN opens an indented block.
Must fix / should fix / tips
Error / warning / note
Errors cap the grade at F and the score at 49, and zero their check's bar.
Issues · Top fixes · Instructions · Names · Checks
Findings · Fixes · Rules · Entities · Checks
The same five tabs.
3. Message decoder
Every code the engine can report. The first part of the code is the area: logic, clarity, prompt, structure, grammar, style, security, literal (AI-sounding phrasing), or nlp (optional hints).
Code
Plain name
In plain words
4. Rule status decoder
Status
Beginner wording
Meaning
✓ read
✓ Clear
A firm instruction the checker can verify.
✓ read (soft)
✓ Clear, but soft
Readable, but SHOULD or MAY lets the AI skip it.
~ unprovable
~ Hard to check
Firm, but its shape can't be verified: split it, or move the extra clause into IF … THEN.
~ unmeasurable
~ Too vague to check
Nothing observable; add a number or a concrete action.
✗ unparsed
✗ Not an instruction yet
Add a modal (MUST / NEVER) and lead with an action verb.
= fact
= Statement, not an instruction
"It is important to …" states an opinion; rewrite as MUST.
5. A template to start from
# Role
You are a <role>.
# Agent Registry
- '<agent_name>': agent that <does what>.
# Variables
- '<flag_name>' is boolean.
- '<tier>' is one of 'gold', 'silver'.
- '<topics>' is list of 'billing', 'roaming'.
# Rules
- You MUST <action> <object>.
- You NEVER <action> <object>.
- IF '<flag_name>' is true THEN You MUST <action>.
- IF '<topics>' includes 'billing' THEN You MUST <action>.
# Routing
- WHEN <situation> THEN You MUST transfer the chat to '<agent_name>'.
6. How the grade is calculated
Check (technical name)
Weight
Can it be checked? (Enforceability)
20%
No contradictions (Consistency)
20%
Firm wording (Hardness)
15%
Tidy layout (Structure)
10%
Talks to the AI directly (Directness)
10%
No secrets leaked (Security)
10%
Says it plainly (Literalness)
10%
Spelling & typing (Style)
5%
Errors, warnings, and notes subtract points from their check, scaled by the prompt's length. Literalness is the exception: each match costs a fixed number of points, up to a cap per pattern. The optional NLP hints never affect the grade.
Errors. Any error (red) drops the grade to F and the score to 49 or less, and sets the check it belongs to to 0: a contradiction empties "No contradictions", an unreadable number limit empties "Tidy layout", a leaked key empties "No secrets leaked".
Grade caps. A check that scores too low limits the grade, however good the rest is. Today: "Can it be checked?" (Enforceability) below 80 caps the grade at B, below 60 at C; "Says it plainly" (Literalness) below 70 caps it at B, below 40 at C. The number is lowered to the top of that grade (89 for B, 79 for C), and the first item in Fixes says how to lift the cap.
Grade
Score
A
90 or more
B
80–89
C
65–79
D
50–64
F
below 50, or any error
Weights, grade bands, and caps are part of the scoring rules.
7. When to switch to Expert
Switch to when you want the technical output only, the full parser reference, or the exported AST format for engineering handoff.
Enterprise Prompt Engineering Guide
A complete operational manual for product managers, analysts, and developers to write provable, deterministic, high-efficiency prompts.
1. The Statement Hierarchy (How the Parser Thinks)
Every line in a prompt serves a specific mechanical purpose. The engine classifies lines in strict priority order:
Line Types & Classifications
Structural Headings (# Role, ### Constraints): Organizes context sections. Treated as metadata, not scored constraints.
Declarations ('risk_flag' is boolean, - 'billing_agent': handles invoices): Binds a variable, agent, or tool to a definition. Only a quoted name or pointer at the start of a top-level line registers in the Entities schema (see section 8).
Assignments (IF 'risk_flag' is true THEN 'current_risk' is true): Changes runtime state when a condition holds. Assignments never declare a variable; the variable must already exist in the schema.
Pointers (@{variable}, @[tool]): Use formal pointers to reference declared entities, variables, or system tools. The compiler treats these as unbreakable atomic references.
Conditionals (IF / WHEN / UNLESS / WHILE / WHENEVER / ONCE / AFTER / AS SOON AS … THEN): Establishes a trigger boundary. Directs the AI to only activate the rule when the condition evaluates to true. A condition line with nothing after THEN opens a block: every more-indented line below it belongs to that condition.
Directives (MUST …, NEVER …): Actionable commands. These are the *only* lines that populate the Rules Tab.
Prose / Persona (You are a helpful assistant): Background setup. Ignored by the contradiction engine because prose cannot be mathematically tested.
Sections that allow prose
Under these headings a line describes; it is not read as a rule. A line that opens with a capitalised verb (Output the JSON.) is no command there, and a passive line gets no rewrite hint. Modal lines (MUST, NEVER) are still rules.
Heading is exactly:role, persona, context, background, notes, note
Heading starts with:example, examples (# Examples of correct conditions)
Every other section reads its lines as rules. Under a registry heading (Variables, State, Tools, Agents, Inputs, Glossary …) text in backticks is a name: `elite-mode` gets no hype, buzzword, hedge or vague note. The same words outside the backticks, or in any other section, are flagged.
Why does the Rules Tab not always start at Line 1?
If Lines 1 through 10 are headings, role descriptions, and data declarations, they are structural. The engine only surfaces a line in the Rules tab once it encounters an actionable directive (e.g., Line 11: You MUST follow below instructions:). The tab displays verified rules, not raw editor line numbers.
2. Modals, Frequencies & Vague Words
The engine scans for specific force-multiplier words to establish whether a rule is an unbreakable law, a casual suggestion, or an unprovable opinion:
Hard Constraints (Passes Enforceability)
ObligationsMUST, ALWAYS, REQUIRE, ENSURE
ProhibitionsNEVER, MUST NOT, MUST NEVER, DO NOT, DON'T, MUSTN'T, CANNOT, CAN'T
Soft Constraints (Penalizes Hardness KPI)
RecommendationsSHOULD, PREFER, MAY
DiscouragedSHOULD NOT, SHOULDN'T, AVOID
Trigger Words (Penalizes Logic & Enforceability KPIs)
Frequency Overridessometimes, occasionally, at times, usually, mostly, generally, typically, rarely, seldom. (Note: Using these alongside ALWAYS/NEVER triggers a logical contradiction).
Hedgingtry to, attempt to, if possible, where possible, whenever possible, when possible, as much as possible, if you can, ideally, perhaps, maybe, hopefully.
Vague Judgmentsas needed, appropriately, appropriate, properly, proper, relevant, etc, reasonable, reasonably, suitable, suitably, adequate, adequately, sufficient, sufficiently, as appropriate, where necessary, if necessary, and so on, various.
3. Recognized Action Verbs (The Engine Catalog)
For a directive to be proven, its action must lead with an observable, unambiguous verb recognized by the compiler. The engine strictly recognizes the following catalog:
Light Verbs (Object Required):fire, call, invoke, run, trigger, execute, use, perform, apply, do, have, take, bring, move, turn, point, lower, raise, let, get, go, come, stay, remain, be. (These cannot stand alone; they must name their target object, e.g., "MUST execute the plan").
4. The 8 Enterprise Quality Metrics (KPIs)
Each metric evaluates a structural dimension of prompt safety and performance:
1. Enforceability (Weight: 20%)
Measures whether statements can be programmatically verified against output text. Evaluates if verbs are observable and bounds are measurable.
✗ Unmeasurable: You MUST be helpful and polite.
✓ Enforceable: You MUST greet the user by name and ask at most 1 question.
2. Hardness (Weight: 15%)
Measures the ratio of hard constraints (MUST/NEVER) to soft suggestions (SHOULD/MAY). High hardness minimizes hallucinations.
✗ Soft: You should avoid mentioning competitors.
✓ Hard: NEVER mention competitor names or pricing.
3. Directness (Weight: 10%)
Checks for imperative syntax. Passive voice and third-person references introduce execution latency and role ambiguity.
✗ Passive: The inquiry is to be escalated by the agent.
✓ Direct: You MUST escalate the inquiry to the billing team.
Every passive (is defined, must be closed, are reviewed) is a voice/passive warning, always on, and the line counts 0.5 in the Directness average. Inside a condition (IF the user is verified THEN, Once the idea is defined, …) the fix is a declared variable: IF 'user_verified' is true THEN …. Auxiliaries, participles, and the 0.5 are part of the scoring rules.
4. Consistency (Weight: 20%)
The contradiction engine. Scans for overlapping numerical ranges, mutually exclusive rules, conflicting frequencies, or inverted quantities.
✗ Contradiction: Line 12 requires "at most 3 bullets", but Line 45 demands "at least 5 bullets". Consistency drops to 0, the score to 49, and the grade to F.
5. Structure (Weight: 10%)
Validates hierarchy, XML tag encapsulation (<rules>…</rules>), nested indentation, and uniform list bullet formatting.
6. Style (Weight: 5%)
Evaluates prompt hygiene: eliminates trailing whitespaces, repeated words ("the the"), typographical spelling mistakes, and curly lookalike quotes.
7. Security (Weight: 10%)
Scans for accidentally committed secrets: AWS Access Keys, OpenAI tokens, Anthropic API keys, Slack Webhooks, or private RSA keys.
8. Literalness (Weight: 10%)
Flags phrasing typical of AI-generated text. A Forge prompt reads like pseudo-code: one literal, checkable instruction per line. Each match is a literal/* warning that costs its pattern's points, up to the pattern's cap (see section 11). Grade caps: Literalness below 70 caps the grade at B (number clamped to 89); below 40 caps it at C (79). Caps for any facet are set in the scoring rules.
✗ Generated: You are not a chatbot, you are an elite strategist.
✓ Literal: You are a product strategist.
5. Mathematical Conflict Detection (What Fails a Build)
The engine proves mathematical impossibility before deployment. Any proven conflict sets its KPI to 0, clamps the score to 49, and locks the grade to an F:
Numerical Bounds:at most 3 sentences vs at least 5 sentences. Both cannot simultaneously be satisfied.
Temporal Windows:within 90 seconds vs at least 2 minutes. Units of time are converted before comparing.
Monetary Thresholds:at most 50 USD vs at least 100 USD.
Cardinality: Declaring There is only one tool alongside There are several tools.
Quantifier Squares: Directing All refunds are approved alongside No refunds are approved.
Deadlocks:MUST send the survey before you close the chat alongside MUST close the chat before you send the survey. Rules under exclusive conditions (IF 'vip' is true / OTHERWISE) keep separate timelines and never deadlock.
Ranking Loops:'gold' is higher priority than 'silver' alongside 'silver' is higher priority than 'gold'.
Bypassed Gates:MAY issue a refund only if 'verified' is true alongside an unconditional MUST issue a refund (logic/only-gate).
How bounds are compared. Each bound becomes a range: at most 3 is [0, 3], at least 5 is [5, ∞), less than 3 is [0, 3). A prohibition flips it: NEVER write more than 3 sentences is [0, 3]. Two ranges on the same unit, under the same conditions, that do not overlap are a contradiction when at least one of the two rules is hard.
Bound syntax is strict. A number in a rule must be written as comparator + number + unit, all from the scoring rules: at most 3 sentences, exactly 2 options, within 5 minutes. Anything else (list 3 options, at most $50, at most 1 clarifying question) is a syntax/invalid-bound error.
6. Compound Statements and the AST Compiler
How does the engine handle and / or in directives?
The engine utilizes a Recursive Descent Parser to build an Abstract Syntax Tree (AST) in memory. This means it physically maps the grammatical branches of your sentence rather than just scanning for keywords.
When you write a compound statement like "You MUST classify @{query} AND select @{agent}", the AST automatically decouples the sentence into distinct execution branches:
Branch 1:MUST → classify → @{query}
Branch 2:MUST → select → @{agent}
The Result: You can safely write natural, token-efficient compound sentences without breaking the contradiction engine. If Line 80 says "NEVER select @{agent}", the compiler will mathematically cross-reference the AST branches and instantly catch the collision against the second half of your compound statement.
7. NLP Hints (Optional, Never Scored)
The NLP hints setting (under Settings in the toolbar) turns on a second opinion from compromise.js, a small part-of-speech tagger that ships with this app and runs offline in your browser. Its notes appear under Notes in the Findings tab. They never change the score: the grade comes only from the deterministic rules and the verb catalog above.
passive"The inquiry is to be escalated by the agent" → "You MUST escalate …"
verb-synonym"MUST utilize the search tool": "utilize" is a verb but not in the catalog; nearest catalog verb is use.
verb-position"MUST in every reply cite the source": the verb is "cite"; lead with it.
future"The agent will greet the user" describes behaviour; write "You MUST greet …".
compound"…verify the identity and update records": "update" could be a noun or a verb. The rule reader treats it as a list item, and the tagger says it reads as a verb, so check whether this is two actions.
8. The Symbol Table: Declaring Variables, Agents & Tools
Tier 1: What counts as a declaration
A name enters the schema only when all of these hold:
It is a quoted name ('risk_flag') or a pointer (@{query}, @[search_kb]) at the start of a line or bullet.
It is followed by is, are, :, =, or means.
It sits at the top level. Anything inside an IF condition or a THEN outcome, inline or in an indented block, is never registered.
Under a heading such as # Agent Registry, # Variables, or # Tools, bare bullet names also register (- risk_flag: boolean). JSON inside code fences or brace blocks is ignored.
The engine infers a kind for each entry. It uses the heading (agents, tools, variables), the pointer type (@[…] is a tool, @<…> is an agent), and the definition (boolean, number, one of 'a', 'b', list of 'a', 'b', default to …).
Lists: testing what a variable holds
A variable declared as list of 'a', 'b' can hold several values at once (for example, every topic the customer raised). Test it in a condition with includes or does not include; several values joined by or test for any of them.
- 'topics' is list of 'billing', 'roaming'.
- IF 'topics' includes 'billing' THEN You MUST transfer the chat to 'billing_agent'.
- IF 'topics' does not include 'billing' or 'roaming' THEN You MUST ask what the customer needs.
These words are read inside conditions only. In a rule, does not include keeps its usual meaning. Two includes rules on different values both apply when the list holds both, so they never raise guard-priority; two that can match the same value do.
Tier 2: Undeclared variables
Every pointer, and every quoted name shaped like a variable (snake_case, dotted.path, camelCase, or `backticked`), is checked against the schema. So is any quoted name on the left of a condition or assignment. A miss raises undeclared-entity. A dotted path such as 'historical_overage.has_overage' passes when its root is declared.
Literal values are not checked. That covers the right side of a comparison ('tier' is 'gold') and quoted phrases (say 'Thank you for calling').
✗ IF 'risk_flag' is true THEN 'current_risk' is true. with no declaration of 'current_risk'
✓ Add - 'current_risk' is boolean. to the Variables block.
9. Export AST
Export AST downloads the parsed syntax tree as JSON or YAML for backend orchestration. The file holds the entity map, every node with its condition scope and action branches, all variable references, the diagnostics, and the current score. It is validated before download. The format is identified by schema: "syntaxforge/ast" and version: 1.
10. Literalness Catalog (Phrasing Typical of AI-Generated Text)
Every pattern below is part of the scoring rules, with its points, its cap, and its wording. The facet scores 100 − Σ min(cap, points × matches). Code fences, comments, notes, and tag lines are never scanned. The Builder runs the same patterns on every free-text field as you type.
Code
Family
Pattern
Points / cap
Instead of
Loads with the grammar.
AUTO-FIXING...
Work in progress. The Matrix is still being built, so some parts may change or not work yet. What you make here is saved only in this browser: use Export to keep a copy.
The Matrix
// Architect. Map. Bind.
The Quarry
// Cut. Shape. Supply.
More
How it works
Make word lists. A list holds the words that can fill one blank in a sentence. {change} = change, update, edit
Write sentences with blanks. Click + Word list on a sentence (or type {) to put a list in a blank. How do I {change} my beneficiary?
Get every combination as rows in a spreadsheet, each with its labels, grammar checked. How do I change my beneficiary? · How do I update my beneficiary? · How do I edit my beneficiary?
No AI is used. The rows cover the ways of asking that you write here; they do not replace real messages from your customers.
1 Setup
Pick one to see how a set is built, then change it to fit your business. Or build your own below.
Label columns (one per label, e.g. intent, language)
2 Word lists
Each list holds the words that can fill one blank. Click a list to see or change its words.
No word lists yet. Start from a ready-made set, or add a list.
3 Sentences
Write a sentence the way a customer would say it. Where the words can change, click + Word list (or type {) and pick a list, e.g. {ask} {change} my {beneficiary}. Under each sentence, fill in its labels: every row made from it gets them.
Tips: add ? to make a blank optional, e.g. {policy?} makes rows with and without it. Untick a sentence to leave it out without deleting it.
No sentences yet.
The Anvil
// Stress. Fracture. Fortify.
Bring your own keys. They go to the Caliper backend over HTTPS with each run, are used for that run only, and are never stored, logged or written to reports. Model settings (not keys) are remembered in this browser.