Development Journey: using `/swarm-brainstorm` on "Jev use cases"

Date: 2026-10-01

Deliverable: this document, DEVELOPMENT-JOURNEY.html, in dot_vs_swarm_ethan\

Brief: "jev use cases that have not been widely discussed" (first run, argument to /swarm-brainstorm)

Model: Sonnet 5.5 (claude-sonnet-5-5) as the parent session. Subagents used the Agent tool with subagent_type: general-purpose and no model override.

Source of this text: the live session transcript and the 14 subagent completion notices. Nothing here is reconstructed from memory of an earlier session.

See also: the brainstorm results, which list every candidate and the two chosen ideas.

The short version. /swarm-brainstorm contains no code and no agent definitions. It is one prompt with three parts: a goal, a search strategy ("as many different angles as possible"), and three evaluation views. The prompt ends with one permission: "You may delegate. Organize the work as you think is best."

In this session the parent model read that permission and chose the structure. It ran the prompt twice, on two different evidence bases. Each run used 7 subagents in two stages. A third stage had no subagents: the parent merged the reports and judged them. The rest of this page shows what happened, stage by stage.

1. The brief: what was actually being asked

The session began after /clear. The user typed /swarm-brainstorm with the argument "jev use cases that have not been widely discussed". The skill text then loaded into the context. Its procedure has four steps: take the topic, run the prompt with {TOPIC} replaced, start subagents as judged useful, and report four things (the chosen idea, the reason, the ranked rejected list, and the number of subagents started).

The skill's source is Ethan Mollick, "The Dot and the Swarm". Its rule: do not define teams, roles, or agent counts. Mollick's own prompt made a model start 3 agents with no team sketch. The skill was written in an earlier session. HANDOFF.md records that it was created, never run, and that its four planned tests were still to do.

Interpretation, and an ambiguity left open

I could not read "jev". The folder gave no clue. A grep for \bjev\b|JEV matched only two minified asset files of the saved article (1580.d88a54d8.css and 1580.c49ad9e4.js.download). I asked the user for the full name and started no agent. This cost one turn. The user answered with a second invocation: "jev use cases that have not been widely discussed. do search/research on jev". That is the brief the agents worked from.

Later the user changed the evidence base: "forget your earlier research results. use these instead", followed by two URLs, the TypeSafe AI launch blog and the yibie/awesome-jev list. I treat this as a second run of the same skill. I kept the first run in this document because it shows how the same prompt produced a different structure on different evidence.

Invisible constraints on this session

~/.claude/CLAUDE.md: ASD-STE100 sentences, precise (non-rhetorical) claims, plain-language explanation, and the "finish, or say what you left" rule.
The ponytail mode (level full) and focus mode. Focus mode means the user saw only my final message of each turn. Each final message therefore had to carry the findings by itself.
Two skills: swarm-brainstorm and, for this document, dev-journey.

2. Setup: how the session reached a working state

There was no environment to repair. The work needed only the Agent tool, WebSearch, WebFetch, Bash, Grep, Glob, and Read. Two items were reused from earlier sessions: the skill file ~\.claude\skills\swarm-brainstorm\SKILL.md, and HANDOFF.md, which told me the skill's purpose, its source, and its untested status.

The folder at minute zero was not a git repository. It held the saved Mollick article (an HTML file and a _files directory of 94 items), prompt.txt, gpt6_summary.txt, cc1_dot_swarm.txt, cc2_dot_swarm.txt, cc3_dot_swarm.txt, and HANDOFF.md.

Identifying the topic (run 1, stage 0, no agents)

After the user said to research it, I loaded WebSearch and WebFetch with ToolSearch and ran three searches in parallel: "JEV AI agents use cases", "jev" claude code OR LLM OR agent OR tool 2026, and "JEV Japanese encephalitis virus new applications 2026". The first two returned the same entity. The third returned virology papers, so I dropped it. Result: Jev is the "System One" decision model from TypeSafe AI. It returns a typed answer with probabilities instead of text. Search results gave 15 Sep 2026 as the launch date. A later agent found a page that says 28 Sep, and I left that unresolved.

3. Design decisions

The skill leaves the structure to the parent. These were my decisions, with the options that lost.

Decision	Chosen	Rejected, and why
Delegate or work inline	Delegate	Inline work would put about 27 fetched pages into one context and give one point of view. The skill also says delegation is allowed.
Tool for delegation	Agent tool, parallel calls in one message	The Workflow tool needs an explicit opt-in ("use a workflow", "ultracode"). The user gave none.
One agent per evaluation view (3 agents)	No	The three views judge candidates, and candidates do not exist at the start. The agents first gathered facts and mapped existing coverage, then proposed ideas.
Stage order	Orient/map, then ideate, then judge	Ideation first would have produced the listicle ideas that the topic excludes. The ideators needed a "do not propose" list from a stage before them.
Who judges	The parent, with no agent	Ranking needs all reports at once. The reports were short (under 800 words each), so the parent could hold them all.
Agent brief	Facts, a "do not propose" list, one angle, one output size cap	A brief with only the topic would have made every ideator repeat the same generic ideas.

Descoped on purpose: no agent for the reader view (see section 4), no code, no repository changes in the research phase, and no memory file written. In run 2 I used no web search at all, because the user limited the evidence to two sources.

4. The crux: how one 25-line prompt turned into stages

The question this document answers is: what does the skill do, and what does the model do? The table below separates them. Section 5 holds the exact prompt of every agent. Sections 6 and 7 cover how the agents communicated and how I chose their number.

Part of the prompt	What the skill supplies	What the parent model chose in this session
Goal: "Generate candidate ideas for {TOPIC} and choose one."	The objective and the "choose one" requirement.	Candidate format: the decision, input/output, fit, failure risk, and a pass/fail test.
Search strategy: "as many different angles as possible"	Only the sentence.	Which angles exist. Run 1 ideators: uncovered domains, architectural roles, personal/civic/science, probability as product. Run 2 ideators: empty and thin domains, blog properties, cross-domain transfer.
Evaluation 1: factual / evidentiary	The view.	Run 1: a facts agent plus a pass/fail test in each candidate. Run 2: a grep check and cost arithmetic that I ran myself.
Evaluation 2: reader perspective	The view.	No agent. I applied it in the final judgment. This is a gap: nobody tested it against real readers.
Evaluation 3: what other publications cover	The view.	Run 1: a coverage-map agent that read 27 pages. Run 2: four mappers over the awesome list, then a novelty grep in every ideator.
"You may delegate. Organize the work as you think is best."	Permission.	Everything else: the number of agents (7 per run), the stages (2 with agents, 1 without), who gets which slice, and the order.

Run 1: open web research (7 agents)

Stage 0: identify the topic

0 agents. 3 parallel searches in the parent.

Stage 1: orient

3 agents in parallel. Facts and limits. Coverage map. Community builds.

Stage 2: ideate

4 agents in parallel, one angle each. Each checked its candidates for prior art on the web.

Stage 3: judge

0 agents. The parent merged 7 reports, applied the 3 views, and ranked the 20 candidates. It chose a policy-corpus contradiction scan.

Stage	Agent role	Tool uses	Tokens	Wall-clock	What it returned
1	Facts and limits (primary sources only)	31	113,672	286 s	Verified limits: 64k context for state plus all questions, 32k for state plus the longest question, 40 requests/s, 100K tokens/s. A list of claims it could not verify.
1	Coverage map of existing use-case articles	38	109,626	147 s	27 pages counted. Saturated: agent safety gating (19 pages), ticket triage (19). Zero pages: healthcare, education, government, manufacturing.
1	Community builds and critiques	15	103,354	200 s	Ten unusual builds and a table of failure reports, such as the fair-die test (82.9% stated, 19.0% accuracy).
2	Ideate: domains with zero coverage	19	94,925	89 s	5 candidates: translation QA, permits, manufacturing reports, archives, medical coding.
2	Ideate: architectural roles inside other systems	10	83,916	69 s	5 candidates, none rated high novelty. Best: delta debugging with Jev as the oracle.
2	Ideate: personal, science, civic	8	80,715	58 s	5 candidates, including genealogy matching and a stale-note checker.
2	Ideate: uses that depend on the probability output and its limits	20	100,468	118 s	5 candidates, including a clause-ambiguity index and an all-pairs contradiction scan.

Totals for run 1: 7 agents, 141 tool uses, 686,676 subagent tokens. The shortest ideator took 58 s and the longest agent took 286 s.

Run 2: two user-supplied sources (7 agents)

Stage 0: get the sources

0 agents. One WebFetch worked (the blog). One failed (the list). Fix: GitHub API plus curl of the raw files.

Stage 1: map the list

4 agents in parallel. Each read a slice of the category files. No web search.

Stage 2: ideate

3 agents in parallel. Each had the maps and checked novelty by grepping the list.

Stage 3: verify and judge

0 agents. The parent ran one grep command, checked the cost arithmetic, and chose dead-letter-queue triage.

Stage	Agent role	Tool uses	Tokens	Wall-clock	What it returned
1	Map: agent-decisions, verification-guardrails, calibration-research (156 entries)	4	93,191	55 s	Patterns and counts. Saturated: GUI action selection (about 19), tool-call gating (about 18), open replicas (about 33).
1	Map: classification-routing, scoring-ranking, content-moderation, data-labeling (115 entries)	5	87,764	54 s	Saturated: coding-agent routing, reranking (about 20). No entry for healthcare, insurance, legal, education.
1	Map: infra-sdks, evaluation, adaptive UI (142 entries)	6	93,169	56 s	23 language SDKs. No entry for n8n, Airflow, Kafka, dbt, Temporal. No concurrent-load latency benchmark.
1	Map: games, robotics, finance, compliance, science, discussions (139 entries)	13	106,596	200 s	12 practice signals with no case page. It corrected two counts in my brief (section 9).
2	Ideate: empty and thin domains	9	103,748	426 s	Insurance routing, clinical-trial pre-screen, rubric scoring, shipment exceptions, product taxonomy.
2	Ideate: exploit blog properties (fan-out, 255 choices, free output)	16	106,712	450 s	5 candidates with cost arithmetic. Best: dead-letter-queue triage, material-change classification.
2	Ideate: cross-domain transfer from odd entries	20	115,809	335 s	Questionnaire pretest, next-file prefetch, voice end-of-turn head, hazard-log map, hierarchical coding.

Totals for run 2: 7 agents, 73 tool uses, 706,989 subagent tokens. The mapping agents read local copies of the list, so three of them finished in under 60 s.

What the two runs show. The same prompt produced the same overall shape twice: a stage that gathers and maps, a stage that ideates from separate angles, and a judgment step in the parent. Both runs used 7 agents. The split differed: 3 then 4 in run 1, and 4 then 3 in run 2. The data does not show why. Two runs on one task cannot support a claim that the model scales the agent count to the task size. HANDOFF.md lists that as an open test, and this session did not close it.

Why the "angles" matter

The skill's search strategy says only "as many different angles as possible". The parent turned each angle into a separate briefing, so the ideators did not repeat one another. In run 1 the briefs shared a "do not propose" list built from the coverage agent's saturated categories. Without the stage before, that list could not exist. This is where the staging changed the content of the ideas.

5. The agents one by one

Section 4 gives one table row per agent. This section gives each agent its own entry: why it existed, what its prompt asked, what it returned, where it fell short, and how I used the result. Under each entry is the exact prompt that the agent received.

How to read the entries. A subagent started with the Agent tool begins with no memory of the session. The prompt is everything it knows. This is why every prompt carries facts, limits, and a "do not propose" list. The agent's last message came back to me as a task notification. Entry numbers run 1.x and 2.x for run 1, and 3.x and 4.x for run 2. Every agent used subagent_type: general-purpose and the default model. The short label in each entry is the description field of the Agent call.

One change to the prompts. The prompts are copied as sent. The only edit is that the local scratchpad folder path in the run-2 prompts is replaced by the placeholder [local scratchpad folder], because the real path contains a user name.

Run 1, stage 1: orient (3 agents)

Agent 1.1: Facts and limits

Call label: Jev facts and limits · 31 tool uses · 113,672 tokens · 286 s

Why this agent. Every later agent needed correct facts about Jev. The search snippets and the listicles disagree with each other on basic numbers. I gave one agent the job of reading only primary sources (the vendor site, the docs, the API reference) and of sorting every claim into "verified" or "not verified".

What the prompt does. It names the entity and repeats the numbers I had from search snippets ("p50 about 230 ms"), without a source. It lists the topics to cover. It names two secondary sources to test, one of which claims a pitfall the vendor omits. It fixes the output at three numbered parts and 700 words. The third part asks for use cases that the listicles miss, so this agent also did a small amount of ideation.

What came back. Three question types (noul, choice, score). Price $0.042 per million input tokens. A 64k token limit for the state plus all questions and a 32k limit for the state plus the longest single question. 255 options for choice. Rate limits of 100K tokens per second and 40 requests per second. Nine documented failure modes for jev-1.13, including counting, math, and date comparison. A reranking result on legal retrieval (top-1 from 5% to 18%, top-10 from 38% to 62%, 1,200 calls for $0.0645). A batching result: 13 questions in one request were 12.2 times cheaper and 10.0 times faster. It listed unverified claims: the gist's error rates for positional references (86 of 320 wrong at 150 items per request), and the "p50 about 230 ms" figure, which has only a community plugin as its source. The vendor gives a range of 70 ms to 500 ms.

Limits. The agent had no API key, so it made no call and worked from documentation only. The agent also reported that a listicle (the Flavio Copes post) quotes rate limits that differ from the vendor page.

How I used it. The 40 requests-per-second limit changed the cost estimate of the run-1 winner. Token cost alone gave about 1.1 hours at 100K tokens per second. The request limit gave about 6.9 hours. The failure list (counting, math, dates) is the reason the winning design gives numbers and dates to code. The agent's 64k and 32k split reached the user in my report, but the four ideators had already received only the 32k figure in their briefs.

Exact prompt for agent 1.1

Topic: "Jev" = the System One decision model from TypeSafe AI (came out of stealth 15 Sep 2026, $40M seed). It returns typed answers with probabilities, not text. About $0.042 per 1M input tokens, output free, p50 about 230 ms. Do web research (WebSearch/WebFetch) on PRIMARY sources: the TypeSafe AI site and docs, launch post, API reference, pricing, benchmarks, input limits, supported task types (classify, check, score, rank, ask), calibration claims, escalation behavior, known pitfalls. Also read https://flaviocopes.com/jev/ and the gist https://gist.github.com/pedramamini/014676fa8684d91bf7000f4623701ada (it claims a 'measured pitfall the vendor docs omit'). Report: (1) verified capabilities and hard limits with numbers, each with its source URL; (2) things claimed by secondary sources that you could NOT verify in a primary source; (3) any capability that suggests a use case the typical listicles would miss. Under 700 words. Be precise; quote numbers exactly.

Agent 1.2: Coverage map of existing use-case articles

Call label: Map covered Jev use cases · 38 tool uses · 109,626 tokens · 147 s

Why this agent. The topic was "use cases that have not been widely discussed". To find what is not discussed, someone had to count what is. This agent is the direct answer to the third evaluation view ("what other publications are covering"), moved to the start of the process.

What the prompt does. It lists ten pages to read. Nine came from my first search; the tenth (the explainx compaction post) came from the second. It asks for counts per category, so the saturated categories become visible, and for the categories with one source or none. It also asks which publication took which angle.

What came back. A count over 27 pages (nine of my ten pages had Jev text; the Kanerika page returned none; the agent found 18 more). Saturated categories: agent safety gating and ticket triage (19 pages each), bulk labeling (15), games and control loops (14), reranking (13), routing (12), moderation (10). Categories with zero pages: healthcare, education, government, manufacturing and supply chain, procurement, translation, UX research, accounting, and robotics on real hardware. Categories with one page: meeting-transcript tagging, voice-agent interruption decisions, network packet-filter loops. It also grouped publications by angle: launch news, tutorial, listicle, critique.

Limits. The Forbes page returned HTTP 403. The Hacker News, Reddit, and X items came from search snippets and one aggregator page, not from the threads. The Hacker News thread the agent fetched was a different one (Jevmem).

How I used it. Its saturated list became the "ALREADY WIDELY DISCUSSED (do NOT propose)" block in all four ideator prompts of this run. Its zero-coverage list became the angle of ideator 2.1.

Exact prompt for agent 1.2

Topic: "Jev" = the System One decision model from TypeSafe AI (launched 15 Sep 2026). Goal: build a COVERAGE MAP of which use cases are ALREADY widely discussed. Read these (WebFetch) and any others you find: huggingface.co/blog/karmen-beatapi/18-practical-jev-use-cases-for-ai-agents, aiblewmymind.substack.com/p/jev-ai-use-cases, kanerika.com/blogs/jev-ai-use-cases/, shop.zimaspace.com/blogs/tech-ai-hub/jev-use-cases-decision-model-examples, manjeet.substack.com/p/9-practical-places-to-use-jev-in, dev.to/ravi_kumar3481/jev-ai-what-it-is-how-it-works-use-cases-benefits-limitations-and-jev-vs-llms-1jc1, mindstudio.ai/blog/jev-use-cases-automation, marktechpost.com/2026/09/27/20-agentic-use-cases-of-typesafe-ais-jev/, ayautomate.com/blog/jev-use-cases, explainx.ai/blog/fast-jev-compaction-claude-code-plugin-2026. Also search for coverage on Hacker News, Reddit, X, newsletters, and TechCrunch-type news about Jev. Report: (1) a deduplicated list of use-case CATEGORIES with how many sources mention each (so I can see which are saturated); (2) the set of categories mentioned by only 1 source or none; (3) which publications covered Jev and which angle each took (launch news, tutorial, listicle, critique). Under 800 words, include URLs.

Agent 1.3: Community builds and critiques

Call label: Jev community builds and critiques · 15 tool uses · 103,354 tokens · 200 s

Why this agent. The coverage agent counts articles. Articles are not builds. I wanted a second view from the people who wrote code, because the unusual use cases and the failure reports live there.

What the prompt does. It names five repositories I had seen in the first search and tells the agent to find more. It lists the places to look. It asks for three outputs: ten unusual builds, failure reports with numbers, and what the community says is missing. The last sentence asks the agent to mark anything it could not verify.

What came back. The agent worked mainly from two curated indexes: awesome-jev and jev-in-the-wild. It read the Hacker News thread, a dice write-up, the Tetris repository, and an arXiv survey in full. It returned ten builds (for example a Tetris player, a SQL token decoder, a persona simulator, a sponsor-segment detector). Its failure table is the most-used page of this run: a fair die gave 82.9% stated probability on face 1 at 19.0% accuracy (chance is 16.7%); a stated 30% risk became 5.3%, 45% became 6.6%, and 55% became 95.9%; the Tetris player cleared 23, 115, and 23 lines on three seeds against 118, 73, and 118 for a keyword regex.

Limits. The agent did not open Reddit, X, or Discord. Many rows in its table are marked "index only", which means it read the index entry and not the source.

How I used it. Its table became the "Known limits from community reports" paragraph of every ideator prompt in this run. It also pointed to a list called awesome-jev (the cobanov repository). You later chose a different list with the same name, yibie/awesome-jev, as the sole evidence base of run 2.

Exact prompt for agent 1.3

Topic: "Jev" = the System One decision model from TypeSafe AI (launched 15 Sep 2026; returns typed answers plus probabilities, not text). Goal: find what real people BUILT or SAID about it that is off the main path. Search GitHub (repos like jev-gateway, jevXagent, jev-use, jev-code, jev-architect, and others you find via search), Hacker News, Reddit, X, blogs, Discord write-ups. Look for: unusual or non-agent applications (data cleaning, science, games, hardware, finance, legal, accessibility, education, security, personal tools), failed experiments, measured pitfalls, criticisms, and comparisons to small classifiers or embeddings. Report: (1) the 10 most unusual real builds or ideas with URL and one-sentence description each; (2) concrete failure or limit reports with numbers; (3) what the community says is missing or unexplored. Under 800 words. Mark anything you could not verify.

Run 1, stage 2: ideate (4 agents)

Agent 2.1: Ideate: domains with zero coverage

Call label: Ideation: uncovered domains · 19 tool uses · 94,925 tokens · 89 s

Why this agent. This is the "go where nobody went" angle: the domains with zero pages in the coverage map.

What the prompt does. It repeats the facts, the community limits, and the saturated list from stage 1, so the agent starts with the same knowledge as the parent. The angle is a list of twelve domains. The task asks for five candidates in a fixed shape (decision, input and output, fit, risk, test) and then a web check for prior art.

What came back. Five candidates: a translation QA gate, permit application completeness, manufacturing nonconformance report routing, archives access and retention review, and a medical coding audit. It dropped four ideas before it wrote: prior authorization, interview coding, short-answer grading, and bookkeeping, because its search found existing Jev work for each. It rated translation QA and manufacturing as high novelty.

Limits. It read search summaries and not full pages. It noticed that one source lists a 64k request limit, against the 32,000 tokens in my brief, and told me to check it.

How I used it. All five went into the rejected list. Translation QA lost on the vendor's note that English works best and other languages less well, and manufacturing lost because no public dataset can test it.

Exact prompt for agent 2.1

Context: "Jev" = TypeSafe AI's System One decision model (launched 15 Sep 2026). It returns a typed answer (label, yes/no, score, rank, choice) with probabilities, never free text. About 230 ms p50, about $0.04 per 1M input tokens, output free, 32,000 token context.
Known limits from community reports: calibration can be bad on chance-like inputs (fair die: 82.9% stated on a face with 19.0% accuracy); stated probabilities are sensitive to option labels and rubric wording; it falsely accepted fabricated law in one UK legal RAG test; weak on Arabic dialects and missing context; batching 40 rows per request breaks ranking that 1 row per request passes; on IMDb it beat classic ML but lost on the other 7 datasets in one test.
ALREADY WIDELY DISCUSSED (do NOT propose these): agent/tool-call safety gating, support ticket and email triage, bulk labeling, games and Doom/Tetris loops, RAG reranking, model routing, content moderation, agent done-verification, computer-use agents, citation checking, prompt-injection screening, context compaction, CI code linting, security log triage, lead scoring, entity resolution, fraud screening, resume screening, contract review, sentiment scoring.
YOUR ANGLE: industries and domains that appear in ZERO of 27 pages read: healthcare admin and clinical-adjacent triage, education and grading feedback, government/public-sector casework, manufacturing and supply chain, procurement, translation/localization QA, UX research and interview coding, accounting/bookkeeping, agriculture, energy, logistics, libraries/archives.
TASK: Propose 5 candidate use cases. For each: the concrete decision Jev makes, the input and output type, why Jev's properties fit (speed, cost, probabilities), the main failure risk given the limits above, and one validation test. Then use WebSearch to check, for each candidate, whether anyone has already built or written about it (report URLs found, or 'none found' with the queries you tried). Mark novelty as high/medium/low on that evidence. Under 700 words. Do not invent facts or URLs.

Agent 2.2: Ideate: architectural roles inside other systems

Call label: Ideation: architectural roles · 10 tool uses · 83,916 tokens · 69 s

Why this agent. The first ideator changes the domain. This one changes the position of Jev in a system: Jev as a part inside an algorithm instead of an assistant that answers a user.

What the prompt does. It repeats the facts and limits, and a second "do not propose" block lists niche builds that the community agent found. The angle lists ten example roles, with the instruction "do not just copy them".

What came back. Five candidates: Jev as the comparator in a merge sort; as the failure predicate in delta debugging; as a sampled production assertion; as a surrogate labeler for A/B pre-screening; as a verifier for semantic-cache hits. It rated none as high novelty. Its best was delta debugging (medium).

Limits. It ran only one Jev-specific search, so its ratings rest on prior art for language models in general. Four of its five candidates match my example roles, and the cache verifier does not. It did not search for evolutionary critics, distillation teachers, or consensus tie-breakers, although my brief listed them.

How I used it. Delta debugging is rank 2 in the rejected list of run 1. The other four lost on novelty: each has published prior art.

Exact prompt for agent 2.2

Context: "Jev" = TypeSafe AI's System One decision model (launched 15 Sep 2026). It returns a typed answer (label, yes/no, score, rank, choice) with probabilities, never free text. About 230 ms p50, about $0.04 per 1M input tokens, output free, 32,000 token context.
Known limits from community reports: calibration can be bad on chance-like inputs (fair die: 82.9% stated on a face with 19.0% accuracy); stated probabilities are sensitive to option labels and rubric wording; falsely accepted fabricated law in one legal RAG test; batching 40 rows per request broke ranking that 1 row per request passed; on 8 classification datasets it beat classic ML only on IMDb.
ALREADY WIDELY DISCUSSED (do NOT propose): agent/tool-call safety gating, ticket/email triage, bulk labeling, Doom/Tetris loops, RAG reranking, model routing, moderation, agent done-verification, computer-use, citation checking, injection screening, context compaction, CI linting, log triage, lead scoring, entity resolution, fraud, resume screening, contract review, sentiment.
Already built but niche (also do NOT propose): Jev as SQL token decoder, Jev as DuckDB/Postgres function, persona-reaction simulation (Jevtown), YouTube sponsor-segment detection, paper triage radar, network IDS per flow.
YOUR ANGLE: new ARCHITECTURAL ROLES for Jev inside other systems, where Jev is a component and not an assistant. Examples of the kind of thing to think about (do not just copy them): Jev as a learned comparator in sorting/search algorithms, as a cheap oracle for property-based testing of fuzzy specs, as the 'critic' step inside evolutionary/genetic search, as a distillation teacher that labels data to train a tiny local model, as an A/B-test pre-screener, as a runtime assertion ('semantic assert') in production code, as a sensor-to-event converter in streaming pipelines, as the judge in eval harnesses for other LLMs, as a differential-privacy-friendly labeler, as a tie-breaker in consensus among agents.
TASK: Propose 5 candidates. For each: the decision, the input/output, why Jev's speed/cost/probabilities fit, the main failure risk given the limits, and one validation test. Then use WebSearch to check whether each has already been built or written about (report URLs, or 'none found' plus queries). Rate novelty high/medium/low on that evidence. Under 700 words. Do not invent facts or URLs.

Agent 2.3: Ideate: personal, science, and civic uses

Call label: Ideation: personal and civic · 8 tool uses · 80,715 tokens · 58 s

Why this agent. The earlier agents leaned toward software and business. This angle looks at people who are not companies: hobbyists, scientists, archivists, journalists, volunteers.

What the prompt does. The angle is a list of about fifteen ideas. One of them (genealogy matching) came from a Hacker News comment in the community agent's report. The task says "pick the ones with the best mix of real need and fit", which gives the agent permission to choose among them.

What came back. Five candidates: a check of a paper's claim against its table; a newsworthiness score for FOIA records; genealogy same-person matching; adjudication of volunteer transcriptions of museum labels; and a stale-note checker for a personal notes vault. It rated volunteer-transcription adjudication as high novelty.

Limits. It opened no page; it read titles and summaries from search. In its report, "built" means "a page that does this was found". The high rating for the transcription idea rests on two search queries, and the agent said so.

How I used it. All five went into the rejected list. Genealogy overlaps entity resolution, which is saturated, and the transcription idea carries its weak-evidence warning there.

Exact prompt for agent 2.3

Context: "Jev" = TypeSafe AI's System One decision model (launched 15 Sep 2026). It returns a typed answer (label, yes/no, score, rank, choice) with probabilities, never free text. About 230 ms p50, about $0.04 per 1M input tokens, output free, 32,000 token context.
Known limits from community reports: calibration can be bad on chance-like inputs; probabilities are sensitive to option labels and rubric wording; weak on Arabic dialects and missing context; falsely accepted fabricated law in one legal test; 40-row batches break ranking.
ALREADY WIDELY DISCUSSED (do NOT propose): agent safety gating, ticket/email triage, bulk labeling, Doom/Tetris, RAG reranking, model routing, moderation, agent done-verification, computer-use, citation checking, injection screening, context compaction, CI linting, log triage, lead scoring, entity resolution, fraud, resume screening, contract review, sentiment.
Already built, niche (do NOT propose): YouTube sponsor-skip, plot-spoiler comment filter, paper triage radar, persona reaction simulation, SQL decoder, Home Assistant sensors, IRS form classifier, Pokemon-playing.
YOUR ANGLE: individuals, hobbies, science, civic and cultural uses. Think: genealogy record matching (suggested on Hacker News, no build found), citizen science image/tag review, accessibility (alt-text sufficiency checks, reading-level gating, captions quality), archive and museum cataloguing, open-data journalism (flagging which records in a FOIA dump matter), personal knowledge management (note-to-note relatedness, 'is this note stale'), wildlife camera or birdsong triage, music/DJ set selection, legal-aid intake, tenant/consumer rights checks, community moderation of local forums, wikis (edit patrol, citation-needed detection), open-source maintainers (issue duplicate detection, PR-template compliance), scientific peer-review checklists, replication-crisis checks (does the paper's claim match its table).
TASK: Propose 5 candidates (pick the ones with the best mix of real need and fit with Jev's properties). For each: the decision, input/output, why Jev fits, main failure risk given the limits, one validation test. Then use WebSearch to check whether each is already built or written about (report URLs, or 'none found' plus queries). Rate novelty high/medium/low on that evidence. Under 700 words. Do not invent facts or URLs.

Agent 2.4: Ideate: uses that depend on the probability output

Call label: Ideation: probability as product · 20 tool uses · 100,468 tokens · 118 s

Why this agent. This is the angle that turns the stage-1 failure reports into material. If the probabilities are unreliable and the wording changes them, a measurement of that behavior might itself be useful.

What the prompt does. It is the only ideator prompt that puts the numbers of the failure reports in front (55% became 95.9%, 45% became 6.6%). The angle says "AND the limits above", so the limits are part of the requirement. The task adds a pass/fail threshold to each validation test.

What came back. Five candidates: a clause-ambiguity index (the spread of answers under reworded questions); a phrase-level leakage probe; an all-pairs contradiction scan of a policy corpus; a label-noise audit with a stability gate; and a difficulty stratifier. It proposed one shared design for all five: run every item in both option orders and under several wordings, and use differences and flip rates, not absolute probabilities. It cited a community audit with a first-listed option bias of 0.37, and a GitHub issue reporting a 47% flip rate and a 64% to 67% second-position bias for Jev as a pairwise judge. It dropped drift monitoring because three tools already exist.

Limits. The 47% flip figure comes from an issue on a different project, and I did not verify it. The agent read search excerpts and opened no paper in full.

How I used it. This agent produced both the winner of run 1 (the contradiction scan, with its both-orders agreement gate) and the runner-up (the ambiguity index). The other three rank in the middle and lower part of the rejected list.

Exact prompt for agent 2.4

Context: "Jev" = TypeSafe AI's System One decision model (launched 15 Sep 2026). It returns a typed answer plus probabilities, never free text. About 230 ms p50, about $0.04 per 1M input tokens, output free, 32,000 token context.
Known limits from community reports: probabilities are NOT reliably calibrated (fair die: 82.9% stated on one face with 19.0% accuracy; a stated 55% risk became 95.9% output while a stated 45% became 6.6%); sensitive to label and rubric wording; it can emit a wrong but valid value with high confidence; one report says calibration holds near the training distribution and fails on pure-chance inputs; calibration helpers exist (jevcal, Tenbin, jev-trust) with few stars.
ALREADY WIDELY DISCUSSED (do NOT propose): agent safety gating, ticket/email triage, bulk labeling, games, RAG reranking, model routing, moderation, agent done-verification, computer-use, citation checking, injection screening, context compaction, CI linting, log triage, lead scoring, entity resolution, fraud, resume screening, contract review, sentiment.
Already built, niche (do NOT propose): persona reaction simulation, SQL decoder, SQL ORDER BY, sponsor-skip, IDS per flow, paper radar.
YOUR ANGLE: use cases that EXPLOIT or DEPEND ON a property the listicles ignore: the output is cheap, typed, repeatable and carries a probability vector, AND the limits above. Think about: Jev as a measuring instrument (inter-rater agreement studies, measuring ambiguity in a corpus by finding items where Jev's distribution is flat, using wording-sensitivity itself as a signal for ambiguous policy text or ambiguous legal clauses), disagreement between Jev and an LLM as an anomaly detector, using repeated cheap queries with perturbed labels as an ensemble to build your own calibration, label-noise auditing of existing datasets, finding contradictions in a policy corpus by asking the same question of every pair, 'counterfactual probes' that vary one phrase in a document and measure the probability shift (a bias or leakage audit), content-quality drift monitoring over time, red-teaming other classifiers.
TASK: Propose 5 candidates. For each: the decision/measurement, input/output, why Jev fits, how the known limits are handled or turned into the signal, one validation test with a pass/fail threshold. Then use WebSearch to check whether each is already built or written about (report URLs, or 'none found' plus queries). Rate novelty high/medium/low on that evidence. Under 700 words. Do not invent facts or URLs.

Run 2, stage 1: map the list (4 agents)

Agent 3.1: Map: agent decisions, guardrails, calibration

Call label: Map agent/guardrail/calibration entries · 4 tool uses · 93,191 tokens · 55 s

Why this agent. After you replaced the evidence base, the list had about 550 entries and one 231 KB README. The size made it unsuitable for one agent. I cut it by category file into four slices of about the same size and gave each slice to one agent. The slicing is the main design choice of stage 1 in run 2.

What the prompt does. It restates the rule (two sources only, no web search, ignore earlier research) and gives the blog facts, so the agent can judge "expected but absent". It asks for patterns with counts, saturation, raw gaps, and unusual entries. The words "raw gaps (do not judge them yet)" keep the mapping step apart from the idea step.

What came back. About 156 entries by its hand tally (60, 47, and 49). Saturated patterns: GUI and browser action selection (about 19), pre-execution tool-call gates (about 18), code review with plain-English rules (about 13), open and local Jev replicas (about 33). Thin patterns: wake gating, RAG answer withholding, URL gating. Gaps: wikiracing and map-reduce (the blog names both), business workflow routing, retry and backoff, multi-agent consensus, threshold-selection studies. Unusual entries: a conversational agent with no language model, a calculator with no arithmetic, a 706,048-parameter specialist that scored 99.7% against Jev's 83.6% on form filling, and an open model that completed 38.5% of web tasks against 16.7% for Jev 1.13.

Limits. The counts are hand tallies and can be off by one or two, because some entries fit two patterns.

How I used it. The two comparisons against specialists (99.7% to 83.6%, and 38.5% to 16.7%) went into every ideator prompt as "documented limits". The gap list fed the angles of the ideators.

Exact prompt for agent 3.1

You map what an awesome-list already covers. Evidence base is ONLY two sources: (1) the TypeSafe AI launch blog https://typesafe.ai/blog/introducing-system-one-models-and-jev and (2) the awesome-jev list https://github.com/yibie/awesome-jev. Local copy of the list: [local scratchpad folder]\awesome\ (README.md is the aggregate, 231 KB; categories\*.md are the parts). Use Read/Grep on those files. Do not use web search. Ignore any earlier research you may have seen.
Blog facts: Jev takes unstructured state plus a typed question and returns a typed value (choice up to 255 options, score, boolean) with calibrated probabilities and confidence. No free-text output. 70ms-500ms end to end. $0.042 per MTok input, output free. All outputs generated in parallel. Blog named examples: Doom gameplay, wikiracing, workflow routing, map-reduce over large datasets, LLM output verification/guardrailing.
YOUR SLICE: categories\agent-decisions.md, categories\verification-guardrails.md, categories\calibration-research.md. Read all three fully.
OUTPUT (under 700 words): (1) the distinct decision PATTERNS in your slice, each with an entry count and 1-2 example entry names with URLs; (2) which patterns are saturated (5+ entries) and which have 1-2 entries; (3) decision types or workflow positions you EXPECT to see in these categories but do NOT, listed as raw gaps (do not judge them yet); (4) any entry that looks unusual or surprising, with URL. Quote entry text exactly when you cite it.

Agent 3.2: Map: classification, scoring, moderation, labeling

Call label: Map classification/scoring/labeling entries · 5 tool uses · 87,764 tokens · 54 s

Why this agent. This slice holds the categories where most "ordinary" Jev uses live, so it is the best place to see which industries are absent.

What the prompt does. The output request differs from the first mapper in one place: it asks for INDUSTRIES and DOMAINS as well as patterns, and for data types as well as decision types in the gap list.

What came back. 115 entries (59, 38, 10, and 8 by file). Saturated: coding-agent model routing (about 13), retrieval and reranking (about 20), email and inbox triage, document classification. Thin: output guardrails (one entry), citation verification, text-to-SQL. Gaps: healthcare, finance, insurance claims, legal review, education, e-commerce categorization, manufacturing inspection, logistics, audio, video and image moderation, hate-speech moderation. Notable entries: a smart-meter anomaly triage with a large-scale claim written like marketing; a cost study that measured Jev at 6.6 to 12.7 times an LLM's token cost on its task; an extraction tool that is 10 to 26 times cheaper than another but scores F1 84.2 against 88.5; a bounding-box entry that is not a typed choice.

Limits. The agent searched only its own slice. A gap in its report can be filled elsewhere in the list.

How I used it. Its industry gaps are the base of the angle of ideator 4.1. The cost study went into the ideator prompts as a documented limit.

Exact prompt for agent 3.2

You map what an awesome-list already covers. Evidence base is ONLY two sources: (1) the TypeSafe AI launch blog https://typesafe.ai/blog/introducing-system-one-models-and-jev and (2) the awesome-jev list https://github.com/yibie/awesome-jev. Local copy of the list: [local scratchpad folder]\awesome\ (README.md is the aggregate, 231 KB; categories\*.md are the parts). Use Read/Grep on those files. Do not use web search. Ignore any earlier research you may have seen.
Blog facts: Jev takes unstructured state plus a typed question and returns a typed value (choice up to 255 options, score, boolean) with calibrated probabilities and confidence. No free-text output. 70ms-500ms end to end. $0.042 per MTok input, output free. All outputs generated in parallel. Blog named examples: Doom gameplay, wikiracing, workflow routing, map-reduce over large datasets, LLM output verification/guardrailing.
YOUR SLICE: categories\classification-routing.md, categories\scoring-ranking.md, categories\content-moderation.md, categories\data-labeling-curation.md. Read all four fully.
OUTPUT (under 700 words): (1) the distinct decision PATTERNS and the INDUSTRIES/DOMAINS in your slice, each with an entry count and 1-2 example entry names with URLs; (2) which are saturated (5+ entries) and which have 1-2 entries; (3) industries, data types, or decision types you EXPECT to see but do NOT, listed as raw gaps (do not judge them yet); (4) any entry that looks unusual or surprising, with URL. Quote entry text exactly when you cite it.

Agent 3.3: Map: infrastructure, evaluation, adaptive UI

Call label: Map infra/eval/UI entries · 6 tool uses · 93,169 tokens · 56 s

Why this agent. The infrastructure file is the largest one (98 entries). It answers a different question from the other slices: which tools a builder can already plug Jev into, and which they cannot.

What the prompt does. It changes the unit of mapping from "decision pattern" to "kind of project". The gap request names integration targets, benchmark types, and UI decision types as examples, to steer the agent toward the questions a builder would ask.

What came back. 142 entries (97, 35, and 10). About 23 language SDKs, about 17 agent connectors, about 14 framework adapters, about 13 local runtimes, 5 database extensions. Gaps from a keyword search of the infrastructure file: no entry for n8n, Airflow, Kafka, dbt, Temporal, CrewAI, Redis, Elasticsearch, Qdrant, Cloudflare Workers, VS Code, Slack, Excel, or OpenTelemetry; no benchmark of latency under concurrent load, although the blog's claim of 70 ms to 500 ms is central; no adversarial or long-context benchmark. It also reported: "Jev Does Not Play Dice" (82.9% on a face at 19.0% accuracy).

Limits. Its keyword search said LangGraph had no entry. Another agent later found one (section 9, item 4). The agent itself noted that it searched only its slice.

How I used it. This report is the origin of the angle of ideator 4.2 (workflow engines, map-reduce, fan-out). I passed its keyword list to that ideator with the instruction "verify with your own grep".

Exact prompt for agent 3.3

You map what an awesome-list already covers. Evidence base is ONLY two sources: (1) the TypeSafe AI launch blog https://typesafe.ai/blog/introducing-system-one-models-and-jev and (2) the awesome-jev list https://github.com/yibie/awesome-jev. Local copy of the list: [local scratchpad folder]\awesome\ (README.md is the aggregate, 231 KB; categories\*.md are the parts). Use Read/Grep on those files. Do not use web search. Ignore any earlier research you may have seen.
Blog facts: Jev takes unstructured state plus a typed question and returns a typed value (choice up to 255 options, score, boolean) with calibrated probabilities and confidence. No free-text output. 70ms-500ms end to end. $0.042 per MTok input, output free. All outputs generated in parallel. Blog named examples: Doom gameplay, wikiracing, workflow routing, map-reduce over large datasets, LLM output verification/guardrailing.
YOUR SLICE: categories\infra-sdks-integrations.md, categories\evaluation-benchmarking.md, categories\adaptive-realtime-ui.md. Read all three fully.
OUTPUT (under 700 words): (1) the distinct kinds of project in your slice (SDK, gateway, plugin, benchmark, UI pattern...) and the decision pattern each serves, with entry counts and 1-2 example names with URLs; (2) saturated (5+ entries) versus 1-2 entries; (3) things you EXPECT to see but do NOT (for example integration targets, benchmark types, UI decision types), as raw gaps; (4) the most unusual entries with URL. Quote entry text exactly when you cite it.

Agent 3.4: Map: games, physical systems, finance, compliance, discussions

Call label: Map games/physical/finance/discussions · 13 tool uses · 106,596 tokens · 200 s

Why this agent. This slice mixes small categories with the "related practices and discussions" file (96 entries), which holds X threads, Reddit posts, and interviews. Those are practice signals that may have no repository behind them.

What the prompt does. It gives the agent a second job on top of the mapping: to find signals in the discussions file that have no case page in any other category. That job needs a search of the other ten category files. The prompt also contains two numbers from my notes: "scientific-pipelines has 1 entry and compliance-legal has 3".

What came back. The agent corrected both numbers: scientific-pipelines has 0 entries and compliance-legal has 2. The extra count in each file was the template line inside a code block. It mapped 24 game entries, 9 robotics, 8 finance. It listed twelve practice signals with no case page, for example zsh history completion, a CAPTCHA arbitrage at $0.0068 per hundred, narrowing an icon set by phrase, and a 57.1% agent cost reduction. It confirmed that the blog's "map-reduce" and "workflow routing" have no entry anywhere in the list.

Limits. This was the slowest mapper (13 tool uses, 200 s) because of the cross-search of the other files.

How I used it. The twelve signals are the raw material of ideator 4.3. The correction of my two counts is item 4 in section 9.

Exact prompt for agent 3.4

You map what an awesome-list already covers. Evidence base is ONLY two sources: (1) the TypeSafe AI launch blog https://typesafe.ai/blog/introducing-system-one-models-and-jev and (2) the awesome-jev list https://github.com/yibie/awesome-jev. Local copy of the list: [local scratchpad folder]\awesome\ (README.md is the aggregate, 231 KB; categories\*.md are the parts). Use Read/Grep on those files. Do not use web search. Ignore any earlier research you may have seen.
Blog facts: Jev takes unstructured state plus a typed question and returns a typed value (choice up to 255 options, score, boolean) with calibrated probabilities and confidence. No free-text output. 70ms-500ms end to end. $0.042 per MTok input, output free. All outputs generated in parallel. Blog named examples: Doom gameplay, wikiracing, workflow routing, map-reduce over large datasets, LLM output verification/guardrailing.
YOUR SLICE: categories\game-simulation.md, categories\robotics-physical.md, categories\finance-trading.md, categories\compliance-legal.md, categories\scientific-pipelines.md, categories\related-practices-discussions.md. Read all six fully.
OUTPUT (under 800 words): (1) the distinct domains and decision patterns in your slice, each with entry counts and 1-2 example names with URLs; (2) saturated versus 1-2 entries; note that scientific-pipelines has 1 entry and compliance-legal has 3, and say what they are; (3) in related-practices-discussions, which practice signals (X threads, Reddit, interviews) describe uses that have NO standalone case page elsewhere in the list: these are the most valuable finds, list each with URL and the exact claim; (4) things you EXPECT to see but do NOT, as raw gaps. Quote entry text exactly when you cite it.

Run 2, stage 2: ideate (3 agents)

Agent 4.1: Ideate: empty and thin domains

Call label: Ideation: empty and thin domains · 9 tool uses · 103,748 tokens · 426 s

Why this agent. It is the run-2 counterpart of ideator 2.1: the domains that the three mappers reported as empty.

What the prompt does. The prompt differs from the run-1 ideators in two ways. It forbids web search, and it asks for the novelty check as a grep of the local README with at least three keywords per candidate. The "LIST GAPS found by mappers" block passes the mappers' reports to the ideator in condensed form.

What came back. Five candidates: insurance first-notice-of-loss routing; a clinical-trial eligibility pre-screen (a yes/no per criterion, run in parallel); short-answer rubric scoring; shipment-exception handling; product-taxonomy assignment. It dropped support-ticket routing and spam moderation, because the list has entries for both. It required a non-Jev baseline in every test (for example TF-IDF with logistic regression), citing the specialist that beat Jev 99.7% to 83.6%. It rated four as high novelty (zero hits for terms such as insurance, adjuster, clinical, patient, student, teacher, shipment).

Limits. It was the second-slowest agent (426 s). The medical evidence it cited is exam-based. It flagged rubric scoring as the riskiest idea because of a subjective-scoring test in the list where no model beat the label base rates.

How I used it. All five went into the rejected list of run 2. Insurance and shipment routing are new industries on a pattern the list already covers heavily (routing), and they rank 4 and 5.

Exact prompt for agent 4.1

Evidence base is ONLY two sources: (1) TypeSafe AI blog https://typesafe.ai/blog/introducing-system-one-models-and-jev and (2) the awesome-jev list https://github.com/yibie/awesome-jev (local copy: [local scratchpad folder]\awesome\ ; README.md aggregates categories\*.md; use Grep/Read). No web search. Ignore any earlier research.
Blog facts: Jev takes unstructured state plus a typed question; returns a typed value (choice up to 255 options, score, boolean) with calibrated probabilities and confidence; all outputs generated in parallel; no free text; 70ms-500ms end to end; $0.042 per MTok input, output free; blog calls 0% type error rate 'non-empirical'; blog's own caveats: needs a schema defined in advance, workflow evals were made by TypeSafe's own team. Blog-named uses: workflow routing, classification/scoring/extraction, map-reduce over large datasets, real-time apps, LLM output verification, Doom, wikiracing.
List facts (already SATURATED, do NOT propose): coding-agent model routing, GUI/browser action selection, tool-call gating, code lint/review, retrieval reranking, email/inbox triage, compaction, done-gates, game-playing agents, open Jev replicas, SDKs, MCP servers, calibration audits. Documented limits in the list: a fair-die test gave 82.9% reported probability at 19.0% accuracy; a 706,048-parameter specialist beat Jev 99.7% to 83.6% on its home task; one cost study measured Jev at 6.6-12.7x an LLM's token cost on its task; WebJev open model beat Jev 38.5% to 16.7% on web tasks.
LIST GAPS found by mappers: scientific-pipelines category has 0 entries; compliance-legal has 2 (motion-to-dismiss forecasting, YAML policy engine); no healthcare/clinical triage, insurance claims, education grading, manufacturing inspection, logistics, energy beyond 1 smart-meter entry, customer-support desks, e-commerce categorization, audio/voice, video or image moderation; no hate-speech/harassment/misinformation moderation; output-side LLM guardrails have 1 entry; robotics has no real-hardware results.
YOUR ANGLE: pick the 5 best candidate use cases in these gap domains, favouring ones where Jev's actual properties (typed output, probabilities, parallel fan-out, cost) fit and where the documented limits can be handled. For each: the decision, input and output types, why Jev fits, the main failure risk using the limits above, and one validation test with a pass/fail threshold. Then CHECK NOVELTY by grepping the local list (README.md) for at least 3 keywords per candidate; report the keywords and any matching entries with URL. Rate novelty high/medium/low from that evidence alone. Under 700 words. Do not invent facts or URLs.

Agent 4.2: Ideate: exploit the blog's stated properties

Call label: Ideation: exploit blog properties · 16 tool uses · 106,712 tokens · 450 s

Why this agent. The blog names map-reduce over large datasets, thousands of choices per step, and real-time use. The list has almost nothing for the first. This agent starts from the blog's claims and asks what a builder could do with them.

What the prompt does. It requires the cost arithmetic to be shown for each candidate, at $0.042 per MTok, and it ends the gap list with "verify with your own grep". That instruction matters: the mapper's keyword search (agent 3.3) was one of the things being checked.

What came back. Five candidates with costs: entity resolution with one 101-way choice per record ($1,722 for 10 million records, against $5,040 for pairwise questions); root-cause hop navigation on a service graph ($0.0052 per incident); dead-letter-queue triage with a replay contract ($44.10 for one million messages at 1,050 tokens each); a typed branch node in Airflow or Temporal ($294 per month); and material-change classification of page versions ($71.40 per day). It found that the list does contain a LangGraph entry (typesafe-jev-workflow), which corrects the mapper and my brief. It confirmed zero hits for Kafka, dead letter, DLQ, poison message, and the other terms.

Limits. The token counts per call are the agent's own assumptions. The 450 s duration is the longest of all 14 agents. The agent labeled its tests as its own design.

How I used it. The winner of run 2 came from this agent. I re-ran the cost arithmetic and one grep of my own before I accepted it (section 11).

Exact prompt for agent 4.2

Evidence base is ONLY two sources: (1) TypeSafe AI blog https://typesafe.ai/blog/introducing-system-one-models-and-jev and (2) the awesome-jev list https://github.com/yibie/awesome-jev (local copy: [local scratchpad folder]\awesome\ ; README.md aggregates categories\*.md; use Grep/Read). No web search. Ignore any earlier research.
Blog facts: Jev takes unstructured state plus a typed question; returns a typed value (choice up to 255 options, score, boolean) with calibrated probabilities and confidence; all outputs generated in parallel; no free text; 70ms-500ms end to end vs 3 to 329 seconds for frontier LLMs; $0.042 per MTok input, output free; Doom estimated at about $7/hour for 10 queries/second; wikiracing with hundreds to thousands of choices per step; blog says 193.6x faster and 444.6x cheaper on its own workflow evals ('higher end of real world gains'); blog-named uses: workflow routing, classification/scoring/extraction, MAP-REDUCE OVER LARGE DATASETS, real-time apps, LLM output verification. The list has NO entry for map-reduce, and no integration with n8n, Airflow, Kafka, dbt, Temporal, LangGraph, CrewAI, Redis, Elasticsearch, Qdrant, Cloudflare Workers, VS Code, Slack, Excel/Sheets, OpenTelemetry (mapper keyword search of the infra file; verify with your own grep). No latency-under-concurrent-load benchmark, no adversarial robustness benchmark, no long-context benchmark.
Already SATURATED in the list (do NOT propose): coding-agent routing, GUI action selection, tool-call gating, code lint, reranking, email triage, compaction, done-gates, game agents, SDKs, MCP servers, calibration audits, semantic grep CLIs, DB extensions for semantic filtering (pg-jev, duckdb-jev, grev).
Documented limits: fair-die 82.9% stated vs 19.0% accuracy; specialist small models beat Jev on home tasks; one cost study found Jev 6.6-12.7x an LLM's token cost on its task; parallel-output design means no chain-of-thought.
YOUR ANGLE: ideas that exploit the properties the blog stresses and the list under-uses: huge fan-out (one cheap call per item over millions of items, so output-free pricing matters), 255-way choice with thousands of candidates per step (generalising wikiracing beyond games: e.g. navigation or search over any graph), real-time sub-500ms decisions in a streaming pipeline, and typed output as a contract inside workflow engines. Propose 5 candidates. For each: the decision, input/output types, back-of-envelope cost using $0.042/MTok (show the arithmetic), why Jev fits, main failure risk using the limits, one validation test with pass/fail threshold. Then CHECK NOVELTY by grepping the local list for at least 3 keywords per candidate; report keywords and any matching entries with URL. Rate novelty high/medium/low from that evidence alone. Under 700 words. Do not invent facts or URLs.

Agent 4.3: Ideate: transfer a working pattern to a new domain

Call label: Ideation: transfer from odd entries · 20 tool uses · 115,809 tokens · 335 s

Why this agent. The strangest entries in the list show working patterns in narrow settings. This agent looks for one pattern that could move to another setting. It works from what real builders chose to make.

What the prompt does. It lists about twenty odd entries from the mappers' reports and tells the agent to read the full text in the local list. It defines the move to make with three examples, and requires the source pattern to be named with its entry URL.

What came back. Five candidates: next-file prefetch from a recent-files list (from the zsh pattern); a local head for a voice end-of-turn decision (from stuntd); a questionnaire pretest with synthetic respondents (from the synthetic-survey entry); a hazard-log risk map (from SemanticSpace); and hierarchical code assignment, one choice per tree level (from Jev Prime). It rated the questionnaire pretest and the prefetch as high novelty.

Limits. Every pass/fail threshold is the agent's proposal. It did not read two long lines in the evaluation file that matched "matrix" and "plot" for the hazard-log idea, and said so. Next-file prefetch is probably beaten by a plain recency rule, since a small specialist beat Jev 99.7% to 83.6% on its home task.

How I used it. Its questionnaire pretest is the runner-up of run 2. It uses the wording sensitivity of Jev as the measurement. That rests on one list entry whose repository I did not open.

Exact prompt for agent 4.3

Evidence base is ONLY two sources: (1) TypeSafe AI blog https://typesafe.ai/blog/introducing-system-one-models-and-jev and (2) the awesome-jev list https://github.com/yibie/awesome-jev (local copy: [local scratchpad folder]\awesome\ ; README.md aggregates categories\*.md; use Grep/Read). No web search. Ignore any earlier research.
Blog facts: Jev takes unstructured state plus a typed question; returns a typed value (choice up to 255 options, score, boolean) with calibrated probabilities; parallel outputs; no free text; 70ms-500ms; $0.042 per MTok input, output free.
Already SATURATED in the list (do NOT propose): coding-agent routing, GUI action selection, tool-call gating, code lint, reranking, email triage, compaction, done-gates, game agents, SDKs, MCP servers, calibration audits, semantic grep/DB filters.
Documented limits: fair-die 82.9% stated vs 19.0% accuracy; a 706,048-parameter specialist beat Jev 99.7% to 83.6% on form-filling; WebJev open model beat Jev 38.5% to 16.7%; Jev cost 6.6-12.7x an LLM's tokens on one task.
ODD ENTRIES found by mappers (read each in the local list, grep for the URL or name to get the full text): Jev Prime 'a conversational agent with no language model, where every word is picked from ~4,700 options'; Jev calculator; jevcrypto; stuntd 'learns each decision site from upstream Jev answers, then answers locally and demotes itself on drift'; SemanticSpace (Jev scores as 2D coordinates); jev-synthetic-survey (Jev and GPT-4.1 answering as 300 synthetic respondents); Jevtown (10,000 personas); zsh history completion (picks next command from last 100 history entries, shown greyed out); CAPTCHA solving at $0.0068 per hundred vs a cent each; designer narrowing a large icon set by phrase; Jev deciding which leads deserve a video before HeyGen renders; Halv cut agent cost 57.1%; Stagehand+Jev sending the accessibility tree as state; Mac app routing setup questions to Jev when no language model is loaded; Jev playing Minecraft and poker; jev-canvas voice/webcam drawing; Qualm screen-reading wellbeing app; JevBystander (reads WeChat chats, shows exactly three toasts).
YOUR ANGLE: CROSS-DOMAIN TRANSFER. Look for decision patterns inside those odd entries that work in one narrow setting and have not been applied to a different domain in the list. Examples of the move: 'pick next item from a short history' (zsh) applied to another history-shaped domain; 'distil a decision site into a local model and demote on drift' (stuntd) applied to a new workflow; 'synthetic respondent panel' applied to a new measurement. Propose 5 candidates. For each: name the source pattern with its entry URL, the new domain, the decision, input/output types, why Jev fits, main failure risk using the limits, one validation test with pass/fail threshold. Then CHECK NOVELTY by grepping the local list for at least 3 keywords per candidate; report keywords and any matching entries with URL. Rate novelty high/medium/low from that evidence alone. Under 700 words. Do not invent facts or URLs.

What the 14 prompts have in common

Every prompt has the same parts, in nearly the same order.

Context. What Jev is, with the numbers that matter. Run 1 gives search-snippet numbers. Run 2 gives the blog's numbers.
Known limits. The failure reports from earlier agents or from the list.
A "do not propose" list. The saturated categories found by the coverage work. Ideators in run 1 get two such lists (widely discussed, and already built but niche).
One angle. The only part that differs in a large way between agents of the same stage.
The task and the output shape. A fixed list of what to report for each candidate, and a word cap of 700 or 800.
An evidence rule. "Do not invent facts or URLs", or "Quote entry text exactly".

The two runs differ in how the novelty check works. In run 1 each ideator searches the web. In run 2 web search is off, and each ideator greps the local copy of the list with at least three keywords per candidate. The skill's third evaluation view ("what other publications are covering") is therefore a web search in run 1 and a grep in run 2.

6. How the agents communicated, and where they did not

Short answer. Every piece of information moved through me, the parent session, and no agent sent a message to another agent. Each agent received one prompt when it started and returned one final report when it finished. Agents in the same stage ran in parallel and did not know that the others existed. Between stages, I chose which findings to pass on, and I rewrote them in my own words.

6.1 The channels, and which ones were used

Channel	Used?	Evidence
Parent to agent: the launch prompt	Used, once per agent	14 launches. The exact prompts are in section 5.
Agent to parent: the final report	Used, once per agent	Each report arrived as one task-completion notice.
Parent to a running agent (`SendMessage`, a follow-up question)	Not used	I made no `SendMessage` call. I resumed no agent. Each agent finished on its first run.
Agent to agent, direct message	Not used	I gave no agent the name or ID of another agent. The transcripts that survive show no `Agent` or `SendMessage` call (see 6.2).
Agent starts child agents	Not used (3 of 14 verified)	The three readable transcripts contain no `Agent` call. For the other 11, see 6.2.
Shared files	Read-only, run 2 only	All seven run-2 agents read one local copy of the awesome-jev files. The one readable run-2 transcript (agent 4.2) shows only `Glob`, `Bash`, and `Grep` calls on that folder. I gave the run-1 agents no shared files.
Agent to user, or user to agent	Not used	You saw only my messages. Your instructions reached the agents only through my prompts.

6.2 What I could and could not verify

I parsed the saved transcripts of the 14 agents and counted tool calls by name, without reading their content into this session. Three transcripts exist and parse: agent 1.2 (ToolSearch 1, WebFetch 30, WebSearch 7, total 38), agent 2.1 (ToolSearch 1, WebSearch 18, total 19), and agent 4.2 (Glob 1, Bash 12, Grep 3, total 16). Each total equals the tool-use count in that agent's completion notice. None of the three contains an Agent, SendMessage, Write, Edit, or NotebookEdit call.

The other 11 transcript files are 0 bytes on disk. I do not know why. For those 11 agents my statement of independence rests on three facts: their reports describe only their own searching and reading, and I never sent them a message. It does not rest on a check of what they did, so a hidden call cannot be excluded by this evidence.

6.3 What the agents knew about each other

Stage 1 agents of both runs knew nothing about the others. They received a topic description (run 1) or a slice assignment (run 2). Stage 2 agents knew only what I put in their prompts. The table shows what I passed from stage 1 to each stage 2 agent, and what I left out. "Condensed" means that I shortened the agent's finding to a phrase or a number and dropped its counts and sources.

Receiving agent	Passed from stage 1 (condensed by me)	Not passed
2.1 uncovered domains	From 1.2: the saturated categories as a name list, and the zero-coverage domains (as its angle). From 1.3: six failure facts (fair die, label sensitivity, UK legal RAG, Arabic dialects, 40-row batching, IMDb).	All of 1.1. The "niche builds" list of 1.3. The category counts of 1.2.
2.2 architectural roles	From 1.2: the saturated list. From 1.3: five failure facts and the niche builds list.	All of 1.1.
2.3 personal and civic	From 1.2: the saturated list. From 1.3: failure facts, the niche builds list, and a genealogy idea from a Hacker News comment.	All of 1.1.
2.4 probability as product	From 1.3: the probability numbers (55% became 95.9%, 45% became 6.6%), the claim that calibration fails on chance-like inputs, and the names of three calibration tools. From 1.2: the saturated list.	All of 1.1.
4.1 empty and thin domains	From my own fetch of the blog: the blog facts. From 3.1, 3.2, 3.3: the saturated list and four limits. From 3.4: the corrected counts (0 and 2) and the gap list.	The practice signals of 3.4. The integration-target gaps of 3.3.
4.2 blog properties	From the blog: the speed, cost, and cardinality claims. From 3.3: the list of absent integration targets and benchmark types, with the instruction to check it by grep. From 3.4: the absence of map-reduce.	The domain gaps of 3.2. The practice signals of 3.4.
4.3 cross-domain transfer	From 3.1, 3.2, 3.3, 3.4: about twenty "odd entries", some quoted exactly and some paraphrased by me. From 3.1 to 3.3: the documented limits.	Most of the saturation counts.

Three facts follow from the table.

The stages overlapped in run 1. I started the four run-1 ideators when agents 1.2 and 1.3 had reported and agent 1.1 was still running. The report of agent 1.1 therefore reached no ideator. It reached me and, through my messages, you. In run 2 all four mappers had reported before I started the ideators.
The ideators did not see each other. In run 1 the four ideators did not see one another's candidates, and in run 2 the three ideators did not either.
Duplicates. I noticed no candidate that two agents proposed independently, but I did not run a systematic comparison.

6.4 Errors that the pass-through changed

An error that spread. I gave the four run-1 ideators a single limit of 32,000 tokens of context. Agent 1.1 reported two limits: 64k for the state plus all questions, and 32k for the state plus the longest single question. Agent 1.1 finished after I had started the ideators, so the correction could not reach them. Ideator 2.1 noticed the mismatch on its own, from a search snippet that listed 64k.
An error that was caught. Mapper 3.3 reported that the list had no LangGraph entry. I passed that claim to ideator 4.2 with the words "verify with your own grep". The ideator found the entry and corrected it.
An error corrected before passing. Mapper 3.4 corrected my counts for scientific-pipelines (0, not 1) and compliance-legal (2, not 3). I passed the corrected numbers to ideator 4.1.

7. How I chose the agents and the number

Short answer. The numbers 3, 4, 4, and 3 were judgments that I made while writing the tool calls, and I have no record of a calculation. This section is a reconstruction from what the transcript shows: my messages, my tool calls, and the prompts. I cannot observe my own selection process any further than that. I tested no other count, so I cannot say that 7 agents per run was better than 2 or 14.

7.1 What the skill decided and what I decided

The skill states no count, no team, and no role. It ends with "You may delegate. Organize the work as you think is best", and its procedure says "Decide yourself how many subagents to start". Everything below was therefore my choice: the use of the Agent tool, the number of agents, the number of stages, the angle of each agent, the labels, and the choice to judge in the parent.

7.2 Things in my context that may have anchored the numbers

The skill text. It cites Mollick's example of a model that started 3 agents without a team sketch.
Your handoff file. In my first turn I read HANDOFF.md. It records Mollick's counts: 3 agents without a team sketch and 13 with a three-team sketch.
Tool descriptions. The Agent tool description says to launch independent agents in one message. The Workflow tool description gives a guideline of fewer than 10 agents per workflow. I did not use the Workflow tool, because you had not asked for one. I cannot rule out that the guideline shaped my sense of scale.

I cannot separate these influences from my own judgment of the task.

7.3 Run 1: how the 3 and the 4 came about

Whether to delegate. I searched first, in the parent, only to learn what "jev" meant. Once I knew, I chose to delegate, because the work needed many pages read and several points of view. The alternative was to read everything in one context.
Three agents in stage 1. I named three questions that need different sources: what Jev is (primary sources), what has been written about use cases (articles), and what people built (repositories and threads). I could not name a fourth distinct question. I did not use one agent, because one agent would mix primary and secondary sources and would have to count 20 or more pages. The second question is the third evaluation view of the skill ("what other publications are covering"), placed first.
Four agents in stage 2. I chose four angles that did not overlap each other or the saturated list. The angles came from four sources: the zero-coverage domains of agent 1.2 (domains), my own reading of the product description (Jev as a component), the wording of your topic (personal and civic uses are less discussed), and the failure reports of agent 1.3 (probability as product). I stopped at four when new angles looked like subsets of these four, for example science, which I folded into the personal and civic angle. I started stage 2 when two of the three stage-1 reports were in. I recorded no reason for not waiting for the third.
The reader view stayed in the parent. I judged this view myself. I wrote down no reason at the time. My untested reconstruction is that a reader view needs the finished candidates, and that a ranking needs all reports at once.
Cost. Each agent used 80,000 to 115,000 tokens. I set no budget and made no cost comparison. Run 1 used 686,676 subagent tokens.

7.4 Run 2: how the 4 and the 3 came about

Four mappers. The list README is 231,420 bytes and the 16 category files total 167,674 bytes. I split the 16 category files by theme into four groups of 49,333; 36,647; 42,770; and 38,924 bytes. I aimed at roughly equal reading loads and at themes that belong together. I recorded no reason at the time for four groups instead of 16 or 2. Reasons that I can offer now, both untested: one agent per file would repeat the prompt overhead 16 times, and two agents would each read 80 KB or more, which risks skimming.
Three ideators. The mappers' gap lists suggested three themes: domains the list lacks, properties that the blog stresses and the list under-uses, and odd entries whose patterns could move to a new domain. I wrote one angle for each. I created no fourth angle and wrote down no reason.
The shape of run 1 carried over. You asked me to forget the earlier results. I discarded the facts, but the structure (gather, ideate, judge) came from run 1, which was still in my context. The two runs share a shape for that reason, as well as for the reason that the same skill prompt drove both. The equal total of 7 agents per run was not planned, and I noticed it only afterwards.

7.5 What this does not show

It does not show how Claude chooses agent counts in general. It is one task, two runs, one model (Sonnet 5.5), and no repeat to measure variance.
It does not show that fewer agents would give a worse answer, because I ran no ablation.
The reasons in 7.3 and 7.4 that are marked as a reconstruction were written after the fact. The transcript shows the choices and the prompts, and it contains no recorded deliberation.

8. Tools and features used

Tool	What it did in this session
`Skill` (via `/swarm-brainstorm`, `/dev-journey`)	Loaded the prompt and the journey-document rules.
`Agent` (`general-purpose`)	Started the 14 subagents, 3 or 4 per message so they ran in parallel.
`ToolSearch`	Loaded the schemas of `WebSearch` and `WebFetch`, which were deferred.
`WebSearch`, `WebFetch`	Identified Jev (run 1). Fetched the TypeSafe blog (run 2).
`Bash` (`curl`, `python`, `grep`)	Listed the repository via the GitHub API, downloaded 18 raw files, and ran the novelty greps.
`Grep`, `Glob`, `Read`	Searched the folder for "jev", read `HANDOFF.md`, found existing files before writing.
Task notifications	Each subagent completion arrived as a system notice with its report, tool count, tokens, and duration. These are the source of the numbers above.

The advisor tool was available, and I did not call it. The Workflow tool was not used (section 3).

9. What went wrong, and the fixes

The topic was unreadable. "jev" matched nothing useful in the folder. I asked in plain text instead of guessing, and started no agent, because a wrong topic would have been copied into every subagent brief.
The search that returned the wrong entity. The query "JEV Japanese encephalitis virus new applications 2026" returned virology papers. The other two queries agreed with each other, so I dropped it.
WebFetch failed on the GitHub list. The tool's answer: "I cannot provide the complete structure you've requested because the web page content provided does not contain the actual list contents." Fix: curl to the GitHub tree API, which showed README.md (231,420 bytes) and 16 files under categories/, then curl of each raw file into the scratchpad.
My brief had four errors, and the agents caught them.
- Run 1: I gave the ideators a 32,000-token context limit. The facts agent found 64k for the state plus all questions and 32k for the state plus the longest question.
- Run 2: I wrote that scientific-pipelines had 1 entry and compliance-legal had 3. The map agent found 0 and 2. The extra count was the template line inside a code block.
- Run 2: I wrote that the list had no LangGraph entry. An ideator found typesafe-jev-workflow.
I gave the agents the sources themselves, which is why they could check my summary of those sources.
I misstated the list size. I said "about 480 entries". The four mappers' tallies sum to 552 (156 + 115 + 142 + 139), and a line count of - lines across the category files gave 568, which includes template lines. The tallies are hand counts and can be off by 1 or 2 per category.
Evidence that could not be checked. The coverage agent could not read Forbes (HTTP 403), and the Hacker News thread it fetched was a different one (Jevmem). The community agent marked many Reddit and arXiv items "index only". The facts agent had no API key and could not run a call, and my final answers repeated these limits.
Weak evidence flagged late. One candidate (volunteer-transcription adjudication) was rated "high novelty" after only 2 search queries. I kept the rating but wrote the weakness next to it.
Hook notices. A "Coach" hook asked me to surface two notes verbatim. The first said the prompt was over 8k characters, which did not match the user's short message. The second said the session had reached about 156k context tokens, and I surfaced both.

Near-misses

Wrong cost estimate for the run-1 winner. A pure token count (about 400M tokens at $0.042 per MTok, so $17) suggested the contradiction scan was easy. The vendor request limit of 40 per second applied to about 999,000 calls gives about 6.9 hours. I wrote both numbers. The request limit is the tighter constraint of the two.
A confident "zero hits" claim. Before I chose the run-2 winner, I ran my own grep for "dead letter", "dlq", "kafka", "poison", "message queue", "rabbitmq" and "sqs" on the README. There were no hits. So I did not have to rely on the ideator's report alone.
Crediting the wrong actor. The skill did not launch the agents. The parent model launched them after it read the permission sentence in the prompt.

Fragility

Agent tool results are summaries by other models. Their counts and URLs were not re-opened by me except in the one grep check.
Two runs on one task give no variance. A third run could pick a different number of agents.
Eleven of the 14 agent transcript files are 0 bytes on disk. The independence of those agents rests on their reports and on my own record of messages, not on their tool calls (section 6.2).
In run 1, I started stage 2 before agent 1.1 had reported, so its corrected context limits did not reach the ideators (section 6.4).

10. Costs, limits, and human moments

Tokens: 686,676 + 706,989 = 1,393,665 subagent tokens across 14 agents. The parent context reached about 156k tokens by mid-session (per the hook).
Quotas and rate limits: none hit. No Jev API calls were made, so no TypeSafe credit was spent.
User actions: (1) invoked the skill, (2) answered the topic question with "do search/research on jev", (3) replaced the evidence base with two URLs, (4) asked for this document and for git readiness, and no permission prompt blocked a tool.

11. Verification

Agent counts and numbers: read from the 14 completion notices in this session, and the sums were computed twice.
List entry counts: checked two ways (mapper tallies, and grep -c '^- ' per file).
Winner claims: the run-2 "zero hits" claim was checked by my own grep. The cost figures ($44.10 for 1M messages at 1,050 tokens, and $24.57 per million decisions at about 585 tokens) were recomputed from $0.042 per MTok.
Not verified: that any proposed use case works. No candidate was run against Jev. No pass/fail threshold comes from the sources; they are agent proposals. The "reader" view was a judgment, with no reader test.

12. Where things stand

Run 1 winner: all-pairs contradiction scan of a policy corpus (both-order agreement gate). Runner-up: clause-ambiguity index.
Run 2 winner: dead-letter-queue triage with a replay contract. Runner-up: questionnaire pretest with synthetic respondents.
Not done: the skill's four planned tests in HANDOFF.md (control topic, small task, large task, team-sketch variant). This session gives one data point only. The question "does the agent count scale with the task" has no answer yet.
Not done: the full rejected-candidate lists live only in the chat text. The agents' raw reports live in task output files under the session's temp directory, which does not persist. If you want them kept, say so and I will copy them into the repository.
Next steps, as options: run the skill on one control topic with a different task size; run the same prompt with the sentence "Use brainstormers, researchers, and a panel of readers." and compare agent counts; add a reader-view agent, since none existed in either run.

13. Knowledge captured

HANDOFF.md was updated in the same change as this document (git state, and a pointer to this file). No memory file was written. The scratchpad copy of the awesome-jev files was not saved to the repository, because it is third-party content.

Written on 2026-10-01 from the live session. Sources: the session transcript, 14 subagent completion notices, ~\.claude\skills\swarm-brainstorm\SKILL.md, HANDOFF.md, the TypeSafe AI launch blog, and awesome-jev.

Development Journey: using /swarm-brainstorm on "Jev use cases"