02Ideas (community)

Decision patterns from the community (with fit verdicts)

TL;DR Twenty-five decision shapes from 61 X posts and 42 linked repos captured 2026-09-20. Scan the Decision lines for judgments your project already makes, then follow Map into the official pages for the real contract. Community tier: other people's claims; the official pages win every conflict.

How to read this

One pattern = one narrow judgment. Fit is our verdict against Jev 1.13 jaggedness: known failure modes and System One Models: strong = bounded options, semantic judgment, code owns the rest; workable = real, caveat named; poor = leans on arithmetic, dates, indirection, generation or huge state. Posted numbers are attributed and unverified.

Agent internals & orchestration

P01 Decisions wearing a generation costume

• Decision is this loop step a bounded check, not writing?
• State the tool result the LLM was about to reason over
• Ask Noul/Choice — "Did the last step satisfy task.constraint?"
• Code tag every call in a real transcript write-vs-decide; move only the decides
• Fit strong — the System One Models thesis itself
• Map How to build software with System One
• Seen @cyrilXBT (25–40% of calls), @0xCarnagee (938 of 1,284)

P02 Model and effort routing

• Decision which model tier handles this
• State the latest user message plus a line per tier
• Ask Choice over local | cheap | frontier | human, criteria naming each tier's job
• Code threshold the confidence, route, keep probabilities for audit
• Fit strong — flat option set, one semantic judgment
• Map Intent routing
• Seen @sydneyrunkle, @dani_avila7, gargpratyush/jev-router

P03 Tool-risk / irreversible-action gate

• Decision may this tool call execute unattended?
• State the call, its arguments, the task, the blast-radius facts
• Ask parallel Nouls — reversible? touches money? affects someone? — plus severity Score
• Code per-action thresholds: execute, log, review, block. Hard limits in code
• Fit strong, if each hazard is its own literal question
• Map Cookbook: Guardrails for LLMs
• Seen @sydneyrunkle (AutoMode), DevMortimer/pi-warden

P04 Loop controller: done, stuck, recover

• Decision did the task finish, is it looping, what to do after a failure
• State task, recent actions, tool results, error code, attempt count
• Ask Nouls for finished / missing info / repeated; Choice over retry | wait | escalate
• Code re-read fresh state to confirm; backoff and caps live in code
• Fit strong — but a high score is not proof the file was written
• Map HTTP status codes, rate limits, retry semantics
• Seen @JoshARosen, thruwire/foreman

P05 Worker routing and branch pruning

• Decision which specialist owns this; which proposed plans survive
• State the work item plus workers available now, or the branches
• Ask Choice over live worker ids; a Score per branch on success, risk, reversibility
• Code rebuild the option list each turn; kill weak branches before a reasoner
• Fit strong — rank wide, read narrow; one dimension per Score
• Map Composite scoring
• Seen @JoshARosen, @Layton_Gott

P06 Confidence-gated human queue

• Decision which automated decisions a person should see
• State the decision record: answer, confidence, cost, reversibility
• Ask usually none — consumes P02–P05; add a novelty Noul if useful
• Code surface low confidence OR high cost OR irreversible; rest stays automatic
• Fit strong — thresholds come from your own labelled set, never from a post
• Map Confidence-gated routing
• Seen @Layton_Gott, @chddaniel

Context & memory management

P07 Compaction: what to drop, and when

• Decision is this tool call still needed; is the session at a safe boundary
• State one tool call plus the task; or recent turns plus window headroom
• Ask Noul per entry ("still needed for task?"); Noul for "work completed or recorded?"
• Code drop or truncate below threshold, survivors verbatim; precision early, recall late
• Fit strong — but chunk it; a 1M-token session exceeds the 64k request limit
• Map Cookbook: Classifying RAG passages
• Seen @mvanhorn (~1M→86K in ~1s), @kunchenguid, tamaratran/fast-jev-compaction

P08 Skill, rule and context selection per turn

• Decision which skills, rules or context slices this turn needs
• State the user turn plus one line describing each candidate
• Ask Choice to rank, plus a separate Noul for "does this turn need one at all?"
• Code load only the winners; the existence Noul stops a forced pick
• Fit strong — this is the shipped skill-suggestion recipe
• Map Cookbook: Skill suggestion
• Seen @swill1ams, kitze/skillbox, EliaAlberti/jev-rules

P09 Memory write/update/delete policy

• Decision what to do with an observation: write, update, delete, link, compact, none
• State the observation plus the matching existing records
• Ask Choice over the six operations; code supplies the target record ids
• Code validate and apply — never let a model emit DB commands
• Fit workable — @Av1dlive's rules baseline hit 23/24 vs a trained policy's 24/24; ship rules first
• Map Testing and evaluating a Jev workflow
• Seen @Av1dlive, codejunkie99/continual-memory-policy-model

Coding agents & dev tools

P10 Staged diff review and semantic lint

• Decision does this hunk carry a correctness, security or house-rule risk
• State one diff hunk, its context, and the rule text verbatim
• Ask Noul per risk class and per rule, plus severity Score, one request per hunk
• Code aggregate with max, not a mean; follow strong signals into a second pass
• Fit workable — literal reading means every rule needs its own precise question
• Map Writing instructions and criteria that Jev reads correctly
• Seen @devagrawal09, devagrawal09/jev-review, devagrawal09/stanley-code

P11 Test-output interpretation

• Decision did tests pass, and is the failure related to this change
• State raw test output plus the diff
• Ask Noul (passed?) plus Choice over unrelated_flake | related | environment
• Code parse exit codes and counts in code; only attribution is a question
• Fit workable — counting is a documented weakness, so never ask "how many failed"
• Map Jev 1.13 jaggedness: known failure modes
• Seen @cyrilXBT (~13s of overhead down to ~0.83s)

Browser, computer use & voice

P12 Next browser action from a code-built menu

• Decision which on-page control advances the task
• State the goal, ids and labels of the controls observed this step, the last result
• Ask Choice over candidate ids — "Which option in candidates advances goal?"
• Code resolve id → predefined action, execute, re-observe; a small LLM writes text args
• Fit strong — the menu is rebuilt each step, so nothing can be invented
• Map Cookbook: Function calling
• Seen @decapostos, browser-use/jev-ultrafast

P13 Picking a site-exposed tool instead of a click

• Decision which of the page's declared tools to call next
• State task, available tool descriptions, previous results
• Ask Choice over tool names; a fast cheap LLM generates the arguments
• Code validate arguments against the tool schema before executing
• Fit strong — @0xidanlevin reports 49/49 tasks with WebMCP vs 25/49 on their click harness
• Map Cookbook: Function calling
• Seen @0xidanlevin, nekuda-ai/WindTunnel

P14 Desktop, mobile, voice and form control

• Decision which element to act on, what the phrase meant, which field to fill
• State OCR/accessibility elements with ids, the live transcript, values extracted elsewhere
• Ask Choice for intent and for target in one request; per field use | check | click | skip
• Code perception is a separate, fallible stage — Jev sees no pixels, extracts no values
• Fit workable — @trycua reports 83.6% for hosted Jev on forms vs 99.7% for their task-specific specialist
• Map Cookbook: Pre-parsed value extraction
• Seen @instantricecook, @trycua, awlevin/typesafe-computer-use

Moderation, guardrails & judging

P15 Jev-as-a-judge for agent evals

• Decision did this captured agent run pass, and how good was it
• State the frozen trace: question, tool calls, evidence, final answer
• Ask Noul for does_pass, Score on an ordered quality rubric
• Code replay the same fixed runs; keep a human-labelled oracle to check the judge
• Fit strong — @LangChain reports 0.44s, $0.00035/call and per-case variance 92–913x below three LLM judges (five-example set)
• Map Cookbook: Self-consistency — nouls
• Seen @LangChain, danielgshea/jev-as-a-judge

P16 Screening what goes in and what comes out

• Decision does this input steer the agent or break rules; does this draft follow policy
• State one untrusted message, or the draft plus the rules or source passage
• Ask Nouls where true means something is wrong; add an uncertain Choice option
• Code aggregate with max; only failures and the uncertain band reach a person
• Fit workable — the docs say jev-1.13 is not hardened against adversarial text
• Map Cookbook: Double-checking citations
• Seen @LeoTava8 (110ms interception), @shannholmberg, brainstormity/Jev-Moderation-Bot

Search, ranking & data at scale

P17 Per-candidate relevance: rerank, SQL predicate, graph edge

• Decision does this candidate answer the query, match the condition, or lead somewhere
• State the query plus one candidate, one row, or a node with its neighbour edges
• Ask Noul per pair for relevance; Choice over neighbour ids for traversal
• Code shortlist with ordinary search or SQL first; Jev re-ranks. Never ask for counts
• Fit strong per pair — the shipped recipe raised top-10 from 38% to 62% on legal queries
• Map Cookbook: Re-ranking, Cookbook: Line-by-line search
• Seen @mvanhorn, realZachi/pg-jev, superagents-lab/jev-search

P18 Map-reduce labelling over a corpus or a timeline

• Decision every semantic label you want per record, page element or transcript span
• State one record, or one segment with its neighbours — only the needed fields
• Ask every independent Noul/Choice/Score in a single request per item
• Code parallel workers; stitch adjacent positives into ranges, aggregate rates in code
• Fit strong per item — the cheapest thing free output tokens unlock; boundary maths stays in code
• Map Cookbook: Parallel questions
• Seen @0xMovez (100k posts × 14 questions, 20.4s, $0.67), @mvanhorn (777 judgments in <0.7s), kitze/unclutter

Marketing, sales & content

P19 Lead and ICP scoring, fit kept apart from intent

• Decision how well does this account match the ICP; does it want to buy now
• State firmographics, role, inbound message, ICP definition verbatim
• Ask separate Scores for fit, intent, urgency, pain — never one blended one
• Code weight the dimensions yourself; change coefficients, not prompts
• Fit strong — textbook composite scoring, and the fit/intent split is the key move
• Map Composite scoring, Score questions
• Seen @yuhasbeentaken, @chddaniel

P20 Signal detection and reply prioritisation

• Decision does this post signal a switch, hire, raise or pain point; which comment to answer
• State one post or comment plus minimal author context
• Ask one Noul per signal type in a single request, plus a reply-value Score
• Code rank by probability, dedupe by author, hand the top slice to a human
• Fit strong — many tiny independent judgments per record
• Map Speculative fan-out
• Seen @yuhasbeentaken, @skeptrune

P21 Creative scoring, ad teardown and content dedupe

• Decision which hook is worth testing first; does this idea already exist on our site
• State one creative with its format attributes; or one idea paired with one existing page
• Ask structural Nouls (does the first line open a loop?); Noul "does existing cover candidate?"
• Code loop the pairs in code; join labels to your performance data, compute rates there
• Fit strong for labels and per-pair dedupe; poor as "here are 50 ideas and my site, pick 10"
• Map Cookbook: Knowledge graph entity alignment
• Seen @RoundtableSpace (430 ads/second, $0.6), @yuhasbeentaken, usenotra/notra

Ops, support & internal tools

P22 Inbound triage fan-out: tickets and email

• Decision owning team, urgency, category, spam, refund intent, frustration, churn
• State one message — plan, account age, recent history; never the archive
• Ask Choice for department or next action, Score for priority, Noul per intent
• Code one request per item, worker pools for volume; your policy combines them
• Fit strong — the canonical documented shape, and no writing is required
• Map Speculative fan-out, Intent routing
• Seen @chddaniel, @akshay_pachaar, @0xMovez (cites 500 emails for ~3.5 cents)

P23 Policy-bounded approval triage (refunds, incidents, discounts)

• Decision approve, review or deny inside a policy you already wrote
• State the request, the policy text, relevant history and fraud signals
• Ask Noul "is this covered by policy?", Noul for fraud signals, severity Score
• Code every currency limit and cap is a code comparison, not a question
• Fit workable — coverage is semantic, money is arithmetic; run recommendation-only first
• Map Jev 1.13 jaggedness: known failure modes
• Seen @Layton_Gott, @chddaniel

Real-time, games, robotics & IoT

P24 Action selection from simulator or device state

• Decision which legal move this tick; does this sensor picture need action
• State the sim or home state as compact JSON, plus the legal move list
• Ask Choice over move ids; Noul per automation condition in plain words
• Code fast model reacts, slow model plans; code owns the tick budget and safety cutout
• Fit workable — text-only and network-bound, so budget 70–500ms; numeric thresholds stay in code
• Map Smart home assistant demo walkthrough
• Seen fhshaik/typesafe-mario, RomanSlack/jev-drone, AboveColin/HA-Jev, @jpschroeder (10Hz needs ~10x lower price)

Markets & trading

Nothing here is investment advice and none of it is a recommendation to trade. jev-1.13 is documented to be unreliable at arithmetic, numeric representations and date/time comparison — most of what a market decision rests on.

P25 Per-block buy/sell decision

• Decision buy, sell or hold given a state your code already computed
• State pre-computed indicators as named English buckets — never raw price arrays
• Ask Choice over buy | sell | hold with criteria describing each regime
• Code sizing, limits, risk caps and kill switches are code; the public repo defaults to dry-run
• Fit poor as usually posted — the judgment is numeric, and calibration is a population property, not a per-trade guarantee
• Map Confidence vs probability
• Seen @oragnes, jarrodwatts/jev-trader (author states profitability is unverified)

Retrofitting an existing agent

• Start order (@k2sbhai): smallest repeated decisions first — context pruning (P07), model routing (P02), tool/skill selection (P08), supervision (P04), review gates (P10), browser/computer actions last (P12, P14). Measure cost, latency and error rate before and after; cheaper with more bad decisions is a failed optimisation.
• Vet community repos first (same post): most were written in launch week and send prompts, diffs, tool inputs or screen text to TypeSafe. Read the source, check what leaves the machine, use a dedicated API key, dry-run, set confidence thresholds, cap max actions.
• Read-only audit prompt for an existing codebase: The typesafe-ai agent skill and Claude Code plugin.

Anti-patterns seen in the wild

• "It can't hallucinate." It cannot break your schema; it can still pick a wrong valid option confidently — Jev 1.13 jaggedness: known failure modes, Confidence vs probability.
• Asking Jev for its own confidence. confidence comes back on Choice and Score; Noul has none. Walkthroughs also invent the types boolean/categorical and a context field; the real fields are state and questions — HTTP API: POST /v1/systemone and GET /v1/models, OpenAPI component schemas.
• One global threshold, or a Noul threshold reused on a Choice. Structural invariants between question types are not guaranteed — Jev 1.13 jaggedness: known failure modes.
• Overlapping Choice options. @cyrilXBT reports about a third of answers were inconsistent until four overlapping categories were rewritten — criteria, not model (Writing instructions and criteria that Jev reads correctly).
• Review velocity, "last 30/60/90 days", settlement windows. Date ordering is a documented failure mode; extract parts, compute in code (Cookbook: Date extraction).
• Dumping a session, sitemap or corpus into one state. 64k per request, 32k for state plus the longest question, and accuracy falls as irrelevant detail grows (State: what you send Jev).
• Asking it to explain, summarise or write the reply. Not trained to generate; chaining choices to fake it is slow and bad (Jev 1.13 jaggedness: known failure modes).
• Counting. "How many of these failed or mention X" — one question per item, add up in code.

Related

• Consult guide: could Jev help this project? — running the "could Jev help this project?" conversation
• Field reports: independent evaluations, critiques, open replicas — independent measurements behind the numbers quoted here
• Community repos: what people built and how they use Jev — the repos named in Seen; Ideas section overview — what this tier is
• Patterns overview, Cookbooks overview, Use-case map by industry, Choosing between Choice, Score, Noul

Sources

Post and repo links are inline in each pattern's Seen in line. The full list of captured posts is in this page's frontmatter sources: (files under raw/x/ in the private repo, captured 2026-09-20; index raw/x/INDEX.json).