We can't find the internet
Attempting to reconnect
Something went wrong!
Hang in there while we get back on track
🔥 TOP SIGNAL
The useful Jev signal today is an implementation pattern, not a replacement-model claim: put a typed control plane in front of the coding model. Jev returns a predefined choice, score, or null decision; Riley Brown used that contract to route a simple request to Nano and an app-architecture request to Sonnet while the downstream model handled files and code.
Matthew Berman shows the same split from another angle: Astra/Codex built a simulated world, Jev made the characters’ decisions, and Jev sits between the prompt and the model that actually answers it rather than coding from scratch. Riley’s 500-email demo finished in roughly 12–13 seconds; his comparison of 0.4 seconds/$0.00004 per Jev decision versus roughly 10 seconds/$0.03 for a traditional LLM is vendor-reported economics, not a coding benchmark.
⚡ TRY THIS
Route the hot path by schema. Define a finite
choiceset, a score scale, or a binarynullquestion; ask several questions over the same state, then hand the resulting task to the appropriate generative model. Kody’s Jev integration maps directly to ticket triage, urgency/escalation, “enough detail to file an issue,” and ready-to-ship scoring, withchoice,score, andnullquestions in one call. For a quick prototype, use Riley’s prompt shape:Create an app that uses Jev. Use Jev. Look up the docs.Jev’s 64,000-token input limit makes payload discipline part of the design.Make UI autonomy hierarchical, not flat. In ThePrimeTime’s Bellatro prototype, start with a structured “god view,” ask one typed question such as
What is your next move in Bellatro?, expose only the actions relevant to the current screen, then decomposeplay handinto a lower-level card-selection loop. Usename/targetpayloads and theenabledflag instead of raw cursor clicks; log the executor, and remove stale fields such as a misleadingreasonvalue. Prime found the raw snapshot consumed roughly 20,000–21,000 input tokens, then reduced it to hand, score, plays/discards, jokers, tarot cards, chips needed, and hand values.Make capabilities portable, not sessions. Riley Brown is centralizing skills, plugins, and keys so he can switch among Codex, GrokBot, Claude Code, Muse, and other platforms; he later says his agents share skills, plugins, and memory, with model switching even in an iMessage agent. Treat this as a portability experiment rather than a production benchmark, but copy the direction: one versioned capability layer with thin host adapters.
Trigger outside the chat and measure each lane. Kody’s subscriptions support platform-level and custom events, which Kent C. Dodds uses to wake a bot from email and Discord. Pair that event layer with Ben Tossell’s harness/token tracker, which splits usage by agent and model, before tuning prompts or adding more autonomy.
📡 WHAT SHIPPED
Claude Code 2.1.277 adds
AGENTS.mdfallback. If a folder has noCLAUDE.md, Claude Code now checks and usesAGENTS.md; the behavior is toggleable in/config. It is implemented as a built-in Claude Code mod, with custom project-instruction mods planned. Simon Willison says this removes his one-lineCLAUDE.mdwrapper workaround, while Romain Huet calls it ecosystem convergence around a shared standard. Study the mods source, especially theAGENTS.mdimplementation.Jev is now exposed directly in Kody Koala. The integration is aimed at fast typed decisions over shared state, including classifying mixed tickets, deciding whether a PR is ready to ship, and assigning a rough quality score. LangChain says Jev reports up to 200× faster inference and 400× lower cost than comparable LLMs on classification tasks; treat that as a reported model claim, not an independent benchmark.
OpenClaw adds a local-to-sandbox handoff. In the latest OC, ask the agent to
Run this [web app] in crabbox and show me [vnc / a portal]; the flow now works when development starts locally, across Linux, macOS, and Windows boxes, with CUA support as well. Steinberger also describes a Discord-connectedroboclawteam server that tracks current and past sessions, while a collaborator cleans (“deslops”) sessions before the PR lands.AgenticLinux packages the agent workstation as an immutable system. The new bootc desktop ships with Docker Engine, Docker Sandboxes,
llmman, and OpenClaw; its root is read-only, updates are atomic from Docker Hub, and rollback is built in. The GitHub repo is worth studying for the deployment boundary around local agents.API-tooling architecture is up for revision. Armin Ronacher proposes a more direct MCP shape—codemode plus OpenAPI plus RAG over OpenAPI documentation—pointing to the OpenAPI-only Radius skill as evidence and arguing that MCP can be layered on top but was not designed for this boundary. Separately,
gognow has an MCP server.
🎬 GO DEEPER
- Riley Brown — JEV: How It Works and What You Can Build: watch the model-router and
choice/score/nullwalkthrough; it is the cleanest explanation of why the decision layer belongs outside the coding model.
- Matthew Berman — We need to talk about Jev...: the hybrid-world demo makes the boundary concrete—Astra/Codex builds the environment, Jev handles repeated in-loop decisions, and a router chooses where each request goes.
- ThePrimeTime — 🚨 TRYING JEV: The new STYLE of AI!!!: this is the useful teardown rather than a polished demo: state reduction, executor bugs, action validity, and the eventual behavioral-tree/state-machine design.
Editorial take: The frontier model should spend its budget on hard reasoning; the harness should own routing, state reduction, action validity, portable instructions, and sandbox handoff.
- Firsthand Jev prototype: ThePrimeTime built a TypeScript/Lua sidecar for a card game: a plugin’s
God viewexposes structured state, typedchoicequestions ask Jev for the next action, and Lua sends synthetic GUI events to execute it. He described Jev as a classification engine, said his usage was still a very small experiment, and reported decisions in roughly 200 ms. - Constrain the action interface: He used phase-specific multiple-choice prompts such as
What is your next move in Bellatro?, with different options for menus, shops, and gameplay rather than one global prompt. Usename/targetaction payloads instead of raw clicks because raw clicks hit whatever is under the cursor; expose only enabled actions and remove the misleadingreasonfield, which was emitting staleunavailablemetadata and surfacing buttons hidden behind overlays. The prototype caught an executor bug where Jev selectedplaybut bothplayandquitwere sent; his coding-agent fix request was deliberately narrow—“Only inside the if statement… Just make the call”—and included adding logging toprepare_action. - Use hierarchical control and context reduction: Because every Jev call was a fresh prompt, he proposed a behavior-tree/state-machine loop: choose a high-level operation such as
play hand,discard hand, orselect hand; if selecting, run a sub-loop to choose cards, then execute the hand and return to the higher-level decision. He suspected the raw game snapshot was hurting decisions, after seeing roughly 20,000–21,000 input tokens, and began reducing it to hand, selected score, plays/discards remaining, chips needed, jokers, tarot cards, and hand values, with a separate compact hand-building guide.
- Local privacy/offline coding-agent pattern: Raine suggested placing a small Liquid Foundation Model on the laptop before a cloud agent: pass material intended for ChatGPT or a cloud-code agent through the local model to shield sensitive information, while using the same on-device model for proactive analysis over laptop data in offline or air-gapped environments.
- Leap-to-agent workflow: Liquid’s Leap developer library and cookbook let developers fine-tune Liquid models and export inference-ready GGUF bundles compatible with llama.cpp for CPU/device deployment. Liquid is beta-testing an automated platform that exposes these capabilities as tools to an existing agentic harness; the harness guides the developer step by step through building and deploying a model. A one-click auto mode is available, but Raine says interactive human-in-the-loop development produces better model quality than skipping the intermediate steps.
- Production evals must evolve: Raine’s warning for deployed agents is that initial evals may be sufficient for the first release, but new production requests can cause distribution shift and make static evals obsolete. The system therefore needs continuously changing evaluation criteria and a loop that incorporates incoming production data.
- Model-routing guidance: Liquid’s LFM2 was described as CPU-oriented, using roughly 80% double-gated 1D convolutions and 20% group-query attention; the current line is at LFM2.5, with released model sizes ranging from 100M to 24B parameters. Raine’s broader routing rule is that recurrent/SSM/continuous-time architectures are strong for audio and other time-series data but weak on text; larger models benefit from simpler, less-biased architectures, while small memory-constrained models can justify more feedback loops and structural bias.
- Production context: Liquid AI CEO Raine reported that Liquid models serve Shopify’s Shop app in production at more than one billion requests per month; he also reported more than 40 million open-model downloads and about 1.5 million downloads per week.
Jev (Typesafe) as a routing primitive — firsthand demo. Riley Brown presents the newly released Jev as a decision-only model rather than a text-generating LLM: it returns a predefined
choice, a user-definedscore, or a yes/nonull, together with confidence, and does not generate output tokens. The practical coding-agent role is therefore a fast classification or model-routing stage; developers must define the candidate categories, action choices, or scoring scale in advance.Replicable email-triage workflow. Riley had Claude create an app that runs Jev over 500 emails, categorizes them, and assigns urgency. The configuration pattern is: define a
nullquestion such asDoes the email mention an opportunity for sponsorship in Riley’s content?, add achoicefield with labels such as brand deal, subscription update, cold pitch, newsletter, and agent native, then add a user-defined importance scale from ignore through critical and an extreme urgent-response level. The demo analyzed all 500 emails in roughly 12–13 seconds and marked six as critical. Riley also added a scam-detectionnull; 55 of 500 emails were flagged, with confidence varying by message.Claude-based model router and setup path. Riley says he built a router in a single Claude prompt that uses Jev to select the downstream model: a simple request selected Nano, while a more involved AI-wrapper request selected Claude Sonnet 5; the resulting app could search the web, generate files, and vibe-code. His suggested setup is to request access at
typesafe.ai, obtain an AI Gateway key, and ask Claude or Codex to “create an app that uses Jev,” provide the key, use Jev, and look up the documentation.Performance tradeoff and agent-loop pattern. Riley reports a vendor comparison of about 0.4 seconds and $0.00004 per Jev decision versus roughly 10 seconds and $0.03 for a traditional LLM; these are presented as benchmark claims, not independently validated results. Jev accepts 64,000 input tokens, substantially less than the larger context windows Riley compares against, so context size is a meaningful limitation for rich business-specific routing. Riley also relays Justin Schroeder’s secondhand autopilot demo, where Jev selects from a finite action tree based on environmental data, and shows a browser flight-booking demo that completes a screen in about seven seconds—an example of repeatedly feeding observations to a fast, constrained action selector.
- Treat Jev as a fast decision layer, not a coding assistant. Matthew Berman reports that Jev’s creator describes it as an RLCD-trained generalized decision model rather than a chat model, claiming up to 200× faster performance and 400× lower cost; the video says output tokens are unlimited/free and input tokens cost fractions of a penny.
- Hybrid orchestration pattern (firsthand demo): Berman says he used Astra in Codex to build a simulated world, then used Jev to power the individual characters’ decisions because Jev is not intended to build code from scratch. A broadcast prompt produced decisions from 50 characters in less than a second.
- Model-routing pattern: Riley Brown’s router routes each prompt to the most efficient and inexpensive model; Berman suggests placing Jev in the middle as the routing decision-maker rather than asking it to answer the prompt itself.
- Browser-agent speed signal: In Berman’s wiki-race demo, Jev completed five page hops in about half a second, while the other displayed models took roughly four to five seconds.
- Suggested automation workflow: In a sponsored Zapier segment, the video proposes sending emails or support tickets into a workflow, using Jev to classify request type, urgency, and priority, then triggering downstream actions across Zapier’s 9,000-plus connected applications; this is presented as a hypothetical integration rather than a production case study.
- Important boundary: Berman says Jev is not suited to coding from scratch or interactive chat, but to answering large numbers of decisions quickly. In a reported chess comparison, Fable reportedly outplayed Jev to a +16 material advantage by move 29, yet Jev answered in 2.6 seconds versus Fable’s 6–15 seconds per move and could win on the clock.
- Armin Ronacher (firsthand account from his company’s software work): Roughly 1½–2 years earlier, he estimated that AI wrote only about 5% of his code “if things went well”; he now describes a rapid shift to “we write it all” with AI. This is an adoption report, not a controlled productivity benchmark.
- Team-level orchestration: His company is trying to put “more people plus one machine” together instead of having one person communicate one-to-one with a machine, with a human mediator in the process. The actionable pattern is shared human mediation around an agent rather than isolated person–agent interaction.
- Jev (Typesafe) as a coding-agent routing layer — firsthand demo: Riley built a model router in a single Claude prompt; it sent a simple request to Nano and an app-architecture request to Claude Sonnet 5, while also supporting web search, file generation, and vibe coding. Jev is not a code-generating LLM: it returns a choice, score, or null plus confidence, so the developer must define the allowed categories, scoring scale, or yes/no criterion before running it. The practical pattern is to use Jev as a fast decision layer and delegate the resulting coding task to a generative model.
- Replicable setup: Riley says Jev is available through the Typesafe waitlist or an AI Gateway, then suggests giving Claude or Codex an AI Gateway key and prompting it: “Use Jev. Look up the docs. I want you to use Jev and create an app with Jev. It’s created by Typesafe.”
- Economics and constraints: Typesafe’s own benchmark, as reported by Riley, puts Jev at about 0.4 seconds and $0.00004 per decision, versus roughly 10 seconds and $0.03 for a traditional LLM; these are vendor-reported comparisons. Jev has a 64,000-token input context and no output-token generation, substantially limiting how much repository or task context can be supplied compared with larger-context generative models.
- Anthropic’s Claude Code Projects lets one conversation spawn parallel cloud sessions, pass context between threads, and continue running after the user leaves; threads currently run in the cloud, with local workflows planned. This is a concrete coordinator UX for long-lived, multi-session coding work rather than a single chat/tool loop.
- Google’s managed-agent runtime pattern combines an Antigravity-based harness with a Credentials API that keeps secrets out of model context using placeholders and trusted-domain egress proxying, plus a Files API for artifact movement and persistent sandboxes; Google claims up to 30% lower costs and 22% higher cache-hit rates. A replicable harness design is to keep credentials in runtime controls and move artifacts through durable files/sandboxes instead of prompt text.
- Use discriminative models for agent control flow, not free-form generation. Community builders are positioning TypeSafe’s Jev for LLM-as-judge, harness routing, subagent creation, structured/typed extraction, and other frequent low-latency decisions; an open reproduction,
openjev-s, combines Qwen3.6-35B-A3B with SGLang radix caching, and Cloudflare exposes Jev through AI Gateway. Do not blindly use a classifier for line-by-line history compaction: Theo argues that removing hidden reasoning can degrade frontier-model performance, while rewriting history can invalidate cached prefixes and cost more than leaving it intact. Keep classification, memory management, and reasoning preservation as separate runtime concerns. - Explicit orchestration and durable shared state are emerging patterns. Google DeepMind’s model-agnostic Stellar Colosseum separates strategy, decomposition, subproblem solving, and verification, with reported results of Codeforces 4263 and 71.0% on TCS-Bench; NVIDIA-associated Agora uses Git commits as shared memory for 13 workers over 12 days and reports reproducible progress on model initialization without gradient updates.
- Cactus Compute released Needle 3, a sliceable 8–29 MB automation model spanning 25–121M parameters and aimed at tool selection and typed extraction on edge devices—an option for pushing routing/extraction work out of a large coding-agent model.
- Firsthand local coding-agent report: A Reddit OP reports 30 days of coding-agent use with Unsloth Qwen3.8-27B-UD-Q4_K_XL on an RTX 5070 Ti plus RTX 4070 Super, Ryzen 5700X3D, and 32 GB RAM, measuring 845.1 tok/s prompt processing, 73.8 tok/s generation, and 0.481 MTP acceptance; the shared
llama.cppconfiguration is here. The reported failure modes were reasoning consuming up to roughly half the context, claimed reasoning bursts up to 60k tokens, tool-call poisoning/loops above 100k context, and fragile KV-cache behavior that triggered full prompt reprocessing. Mitigations were enforced subagents, per-subagent reasoning levels, loop detection with deletion of bad tool calls, and--spec-type draft-dflash,ngram-mod, which the OP says was about 20% faster than MTP+ngram on that hardware. A separate commenter reports that FP8 Qwen3.8-27B generated several million tokens with few tool-call issues up to nearly 262k context using automatic compaction, while looping appeared much earlier at Q4; this is a useful quantization-and-harness reliability counter-signal.
-
Eric Curtin announced AgenticLinux, an immutable bootc desktop for agents with Docker Engine, Docker Sandboxes,
llmman, and OpenClaw preinstalled. It provides a read-only composefs root, atomic updates from Docker Hub, and built-in rollback. - Resources: GitHub repository and project announcement. Peter Steinberger highlighted it as an example of the combination of agents and open source.
- Sanfilippo’s firsthand comparison suggests model choice can dominate coding results: a friend failed to turn a Photoshop mockup PNG into HTML/CSS while using Opus, whereas Sanfilippo says “Astra” performed substantially better for that task.
- In his own 3D-CAD experiment, Sanfilippo says the performance gap between “Astra” and “Fable 5.1” was enormous, and that Astra was substantially better for most coding tasks. The model names and claims should be treated as transcript-faithful rather than independently verified.
- Practical evaluation rule: before accepting someone’s judgment that an AI tool “doesn’t work,” ask which exact model they used; otherwise comparisons may be between materially different capability levels.
- Sanfilippo presents local inference as a privacy- and cost-oriented fallback for users who cannot send sensitive data to external models or pay for unlimited tokens. He says local devices can provide effectively very large token access at low electricity cost, while acknowledging weaker hardware and a substantial device-cost barrier.
-
Thariq Shihipar announced that Claude Code v2.1.277 supports
AGENTS.md: when a folder has noCLAUDE.md, Claude Code checks for and usesAGENTS.mdas project instructions. -
The feature is implemented as a built-in Claude Code mod; Shihipar says custom versions of the project-instruction behavior will become possible through Claude Code’s upcoming mods system. The source for the
AGENTS.mdmod and other mods are available in the Claude Code repository.
- Claude Code 2.1.277 now supports
AGENTS.md: when a folder has noCLAUDE.md, Claude checks for and usesAGENTS.md; this fallback can be toggled in/config.
- Claude Code 2.1.277 adds
AGENTS.mdsupport: when a folder has noCLAUDE.md, Claude Code checks for and usesAGENTS.md; this behavior can be enabled or disabled in/config. -
Simon Willison says this removes his workaround of creating
CLAUDE.mdfiles containing only@AGENTS.md, making shared project instructions easier to maintain. - The feature is implemented as a built-in Claude Code mod, with custom project-instruction mods planned; example mods are available in the Claude Code repository.
Ben Tossell describes a firsthand workflow in which he built a harness and token-usage tracker that splits activity by agent and model, with instructions others can copy for their own setup. The tracker is available at bentossell.com/token-activity/.
- Kent C. Dodds highlights Kody’s secret-provider pattern: it can work with any secret provider while keeping the actual secret value hidden from the agent, yet still allowing the agent to use it. This provides a practical credential-isolation approach for coding-agent workflows. A linked Bitwarden Secrets write-up is available at https://kody.codes/@noah/bitwarden-secrets.
- Firsthand workflow from @knowixbuilds: They built a content “radar” rather than an AI writer. Every hour, Treg collects X posts matching 50 AI keywords, X trends, Google News, and new posts from 45 accounts; Jev then evaluates each topic for audience relevance, meaningful novelty, the creator’s ability to add value, evidence quality, and timeliness. Topics scoring 75% or higher are surfaced for human review, while the author keeps the writing human-authored. This is a reusable two-stage agent pattern: broad automated retrieval followed by a rubric-based relevance gate and human-in-the-loop output.
- The author says the initial system can be built by giving setup instructions to a coding agent, with Treg API-key login handled during setup; the captured source does not include the actual prompt. At the reported configuration, Treg costs about $0.106 per cycle and Jev about $0.007 per cycle, totaling roughly $2.70/day across 24 cycles; a smaller 20-keyword/8-account setup ran at about $0.04 per cycle.
@southpolesteve introduced Probably, a toy programming language powered by Jev: https://probably-lang.southpolesteve.workers.dev. Its orchestration pattern separates responsibilities—Jev makes decisions, an LLM does the writing, and a small program ties the pieces together. The language exposes feels for asking questions, match for routing between descriptions, and while for continuing until something no longer feels true. The author explicitly frames it as a toy, not a production workflow.
- Event-driven agent orchestration (firsthand): Kent C. Dodds says Kody Koala has built-in subscriptions for platform-level and custom events, which he uses to wake his Grok bot from email and Discord. The actionable pattern is to use external event subscriptions as triggers for agent execution, with composable event types rather than a single fixed trigger.
- Kent C. Dodds shared that Jev is now available through Kody Koala: kody.codes/@kentcdodds/jev. He positions it for making fast, typed decisions from shared state.
-
A practical coding-agent pattern is to classify mixed chat or ticket content as bugs, feature requests, or banter, check whether there is enough detail to file an issue, and evaluate whether a draft or PR is ready to ship with a rough quality score. Jev supports asking multiple questions—
choice,score, andnoul—over the same state in one call.
- Peter Steinberger (@steipete) reports a new OC workflow: ask the agent, “Run this [web app] in crabbox and show me [vnc / a portal].” It supports starting locally and later moving the app into a test box when a boxed environment is needed; this previously worked for cloud sessions, and now the local-to-box transition works too.
- The workflow works with Linux, macOS, and Windows boxes. CUA also works across them, which Steinberger says can make the agent more efficient than relying only on screenshots.
- Peter Steinberger describes a human-in-the-loop workflow in which @vhbrzezowski takes over his agent sessions and “deslops” the work before the pull request lands.
- Practical tip: open the home sidebar and ask the claw to reorganize its sessions, using the agent itself to keep session history organized.