Form Intelligence
Forms that think back. Two engines, one result-page contract.
Most forms end with “Thanks for your response.” Askery can end with something useful - a recommendation, a weighted score, an archetype, a tier - generated per respondent from rules you write OR code an AI wrote from your brief. You pick the engine; the result page is the same shape.
Two engines
Same result page. Two ways to power it.
Pick the one that fits the job. Switch at any time before you publish - the result-page shape is shared, so you don't restart.
Smart Rules
Write rules in plain language - an LLM follows them.
- Best for narrative results: archetypes, recommendations, qualitative summaries.
- Owner writes evaluation criteria as prose; tables + IF/THEN work.
- AI-drafted from a one-line description - review and edit before saving.
Best for: Qualitative pages where “sounds right” matters more than “is precisely calculated”.
Decision Engine
Describe your scoring in plain language. AI writes the function. Same answers always produce the same result - no LLM variance.
- Best for scoring, weights, tiered ranking, lookup tables, exhaustive option lists.
- Sandboxed JavaScript: 5s CPU, 128MB RAM, no network - provably no data leaks.
- Visual Block view + Test runner with sample answers - non-developers can verify without reading code.
Best for: Any form that needs deterministic, repeatable scoring - leads, candidates, applications, recommendations - where the same answers always produce the same outcome.
See it in action
Brief → submission → personal result.
An auto-cycling mockup of the end-to-end flow. (When the real screencast lands, this slot becomes a single 30-second video - the surrounding page doesn't change.)
The Pragmatic Researcher
Workflow
Four explicit steps.
Build your form
Create or import the form like normal. Intelligence is a separate, explicit step - you opt in when you're ready.
Pick an engine
Two cards in the builder, one click to switch. Smart Rules and Decision Engine are mutually exclusive per form - there's no hidden mode you have to remember.
Describe - or paste - the logic
Smart Rules: write rules in plain English. Decision Engine: paste your scoring tables and weights, click Generate - AI writes the function in our narrow DSL.
Test, then ship
Auto-generated sample answers + a Run-in-sandbox button. See the exact result a respondent would. Tweak and re-run, then publish.
Examples
Three forms, three result shapes.
Pick the engine the job calls for. Below: a quantitative study-abroad recommender (Decision Engine), a narrative career quiz (Smart Rules), and a B2B lead-scoring intake (Decision Engine).
Find your best country + universities
Sample inputs
- CGPA / GPA
- Budget (₹ lakhs / yr)
- PR importance
- Top engineering branch
- Test score (GRE / IELTS)
What the respondent sees
The Pragmatic Researcher
- • Germany
- • Canada
- • Italy
| University | Tier |
|---|---|
| TU Munich | SAFE |
| McGill | MODERATE |
| ETH Zürich | AMBITIOUS |
Which career path fits how you think?
Sample inputs
- What energises you?
- Risk vs stability
- Detail vs big-picture
- Solo deep work vs collaboration
- Drawn to systems or people?
What the respondent sees
Your archetype
The Pattern Architect
You build mental models faster than most and prefer environments where 80% of the value is in seeing the connection nobody else has yet. Hands-on enough to ship, abstract enough to design the system.
- • Product engineer
- • Quantitative researcher
- • Systems designer
Discovery intake → triage
Sample inputs
- Company size
- Annual revenue band
- Compliance requirements
- Stack already in use
- Decision timeline
What the respondent sees
- • Lead requires SOC 2 + GDPR DPA from their vendor
- • Existing stack overlaps 4/5 integrations
- • Decision in <30 days - matches our enablement cadence
| Owner | Action | By |
|---|---|---|
| AE | 30-min scoping call | Mon |
| SE | Architecture review | Wed |
| Legal | DPA + MSA review | Fri |
Inside the builder
Code · Blocks · Test - three views on the same logic.
Decision Engine isn't a black box. The code is the source of truth; the Blocks view reads it back as labelled chips for non-developers; the Test runner shoots sample answers at the sandbox and shows the result in 100 ms.
Code
export default function decide(
{ answers, score, recommend, tier, output }
) {
score.add("budget", answers.budget < 15 ? 80 : 50);
score.add("research", answers.cgpa * 10);
score.weight({
budget: 0.25, jobs: 0.20,
research: 0.20, ranking: 0.15,
});
recommend.countries(
answers.pr === "yes"
? ["Germany", "Canada"]
: ["USA", "Canada"]
);
return output({
score: score.overall(),
archetype: "The Pragmatic Researcher",
sections: [/* ... */],
});
}Blocks (read-only)
Test
{
"cgpa": 8.7,
"budget": 22,
"pr": "no",
"branch": "cse"
}- score = 82
- archetype = The Pragmatic Researcher
- sections = 4 (list · table · label · prose)
AI-generated code
Paste your scoring brief. Get the function.
The audience is non-technical. The AI writes the Decision Engine function from your brief, in a narrow DSL we control - no `fetch`, no `setTimeout`, no surprises. You review the code, optionally re-generate, then ship.
Scoring tables, weights, country/uni mappings, exhaustive option lists - anything you'd hand a junior analyst.
If CGPA ≥ 8.5 → AMBITIOUS…
+ 80 more lines from your doc.
In our narrow DSL - `score / recommend / tier / output` only. No `fetch`, no `setTimeout`, no globals. You read the diff before saving.
recommend.countries(…);
return output({ score, sections });
Sample answers are auto-generated from your form. One click runs the code in the sandbox; you see the structured result before any respondent ever does.
Under the hood
The sandbox: provably bounded.
Every Decision Engine submission runs in an isolated QuickJS WASM sandbox on a dedicated pod, reachable only inside the cluster, signed with HMAC. Even a runaway script can't take anything down - it hits a cap and we return a typed error.
Pick the right engine
Smart Rules vs Decision Engine.
| Dimension | Smart Rules | Decision Engine |
|---|---|---|
| Authoring | Plain-language rules | AI-generated JavaScript in a narrow DSL |
| Best for | Narrative, qualitative | Scoring, tiering, weighted recommendations |
| Determinism | Variable (LLM) | Deterministic - same answers, same result |
| Speed per submission | 1-6 s (LLM call) | Typically <150 ms (sandbox) |
| Where it runs | Hosted LLM API | Isolated QuickJS sandbox pod inside our cluster |
| Code visibility | - | Code + Blocks + Test in the builder |
| Section kinds | list · label · prose | list · label · prose · table |
Use cases
Built for forms that should give something back.
Anywhere the answer to “what now?” depends on what someone told you.
Recommendations
Suggest the right plan, product, course or destination based on what someone told you.
Match / fitment score
Score a lead, a candidate or an application and show the result with a short rationale.
Personality / archetype
Quizzes that return a type, with a narrative description and next steps.
Tiered classification
Decision Engine bins inputs into SAFE / MODERATE / AMBITIOUS - universities, deals, eligibility.
Weighted scoring
Multiple dimensions, your weights, one overall number. Same answers → same score, always.
Triage & routing
Summarise an intake and point the respondent (and your team) to the right path.
Frequently asked
- What is Form Intelligence?
- An AI-evaluated result page shown to each respondent the moment they submit - a recommendation, a match score, an archetype, a tier or a plan - generated from their own answers via one of two engines you pick per form.
- What's the difference between Smart Rules and Decision Engine?
- Smart Rules: an LLM reads your rules-in-prose and the respondent's answers, writes the result page. Best for qualitative / narrative results. Decision Engine: AI writes a JavaScript function from your brief; the function runs server-side in a sandbox against each submission. Best for deterministic scoring, tiering, weighted recommendations.
- Can a respondent's answer break the Decision Engine?
- No. The sandbox enforces a 5-second wall-clock, 128 MB memory cap, no network, no filesystem, no globals like `fetch` or `setTimeout`. A runaway script hits a cap and we return a typed error; the respondent sees a graceful fallback.
- Where does the code run?
- On a dedicated pod inside our cluster, reachable only via an internal IP. The web app POSTs to it with an HMAC-SHA256 signature; the pod refuses unsigned requests and timestamps older than 5 minutes.
- Do I need to be a developer to use the Decision Engine?
- No. The AI writes the function from your plain-language brief (paste your scoring tables, weights, mappings). The Blocks view shows the logic as labelled chips. The Test runner lets you submit sample answers without writing any code.
- Can the two modes coexist on one form?
- No - they're mutually exclusive per form. The builder makes the choice explicit; the result-page contract is shared, so switching engines doesn't require redesigning the result.
- Can respondents manipulate the AI by writing instructions in their answers?
- In Smart Rules: respondent text is fenced as untrusted data; the LLM is told never to follow instructions inside it. In Decision Engine: respondent answers are values your code reads - they can't influence the code itself.
- Is the result cached?
- Yes - keyed by (form, session). Reloading the result page doesn't re-charge for an LLM call or re-run the sandbox; the structured outcome is stored and re-rendered.
Turn “thanks” into something they'll act on.
Add Form Intelligence to any form in the builder - pick an engine, describe (or paste) the logic, ship.