• Firsthand Jev prototype: ThePrimeTime built a TypeScript/Lua sidecar for a card game: a plugin’s God view exposes structured state, typed choice questions ask Jev for the next action, and Lua sends synthetic GUI events to execute it.ThePrimeTime He described Jev as a classification engine, said his usage was still a very small experiment, and reported decisions in roughly 200 ms.ThePrimeTime
• 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.ThePrimeTime Use name/target action payloads instead of raw clicks because raw clicks hit whatever is under the cursor; expose only enabled actions and remove the misleading reason field, which was emitting stale unavailable metadata and surfacing buttons hidden behind overlays.ThePrimeTime The prototype caught an executor bug where Jev selected play but both play and quit were sent; his coding-agent fix request was deliberately narrow—“Only inside the if statement… Just make the call”—and included adding logging to prepare_action.ThePrimeTime
• 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, or select hand; if selecting, run a sub-loop to choose cards, then execute the hand and return to the higher-level decision.ThePrimeTime 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.ThePrimeTime

• 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. Latent Space
• 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. Latent Space 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. Latent Space
• 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. Latent Space
• 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. Latent Space 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. Latent Space
• 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. Latent Space

• 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-defined score, or a yes/no null, together with confidence, and does not generate output tokens. Riley Brown 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. Riley Brown

• Replicable email-triage workflow. Riley had Claude create an app that runs Jev over 500 emails, categorizes them, and assigns urgency. Riley Brown The configuration pattern is: define a null question such as Does the email mention an opportunity for sponsorship in Riley’s content?, add a choice field 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. Riley Brown The demo analyzed all 500 emails in roughly 12–13 seconds and marked six as critical. Riley Brown Riley also added a scam-detection null; 55 of 500 emails were flagged, with confidence varying by message. Riley Brown

• 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. Riley Brown 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. Riley Brown

• 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. Riley Brown 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 Brown 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. Riley Brown

• 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. Matthew Berman
• 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. Matthew Berman
• 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. Matthew Berman
• 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. Matthew Berman
• 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. Matthew Berman
• 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. Matthew Berman

• 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. ServusTV On
• 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. ServusTV On

• 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. Riley Brown 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. Riley Brown The practical pattern is to use Jev as a fast decision layer and delegate the resulting coding task to a generative model. Riley Brown
• 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.” Riley Brown
• 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. Riley Brown 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. Riley Brown

• 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. Latent.Space
• 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. Latent.Space
• 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. Latent.Space 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. Latent.Space
• 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. Latent.Space
• 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. Latent.Space
• 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.cpp configuration is here. Latent.Space 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. Latent.Space 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. Latent.Space

• 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. @ericcurtin17
• Resources: GitHub repository and project announcement. @ericcurtin17 Peter Steinberger highlighted it as an example of the combination of agents and open source. @steipete

• 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. Salvatore Sanfilippo
• 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. Salvatore Sanfilippo
• 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. Salvatore Sanfilippo
• 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. Salvatore Sanfilippo

• Thariq Shihipar announced that Claude Code v2.1.277 supports AGENTS.md: when a folder has no CLAUDE.md, Claude Code checks for and uses AGENTS.md as project instructions. Simon Willison's Weblog
• 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.md mod and other mods are available in the Claude Code repository. Simon Willison's Weblog

• Claude Code 2.1.277 now supports AGENTS.md: when a folder has no CLAUDE.md, Claude checks for and uses AGENTS.md; this fallback can be toggled in /config. @trq212

• Claude Code 2.1.277 adds AGENTS.md support: when a folder has no CLAUDE.md, Claude Code checks for and uses AGENTS.md; this behavior can be enabled or disabled in /config. @trq212
• Simon Willison says this removes his workaround of creating CLAUDE.md files containing only @AGENTS.md, making shared project instructions easier to maintain. @simonw
• 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. @trq212 +1

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. @bentossell The tracker is available at bentossell.com/token-activity/. @bentossell

• 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. @kentcdodds A linked Bitwarden Secrets write-up is available at https://kody.codes/@noah/bitwarden-secrets. @NoahDavidATL

• 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. @knowixbuilds Topics scoring 75% or higher are surfaced for human review, while the author keeps the writing human-authored. @knowixbuilds 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. @knowixbuilds 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. @knowixbuilds

@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. @southpolesteve

• 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. @kentcdodds

• 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. @kentcdodds
• 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. @kentcdodds Jev supports asking multiple questions—choice, score, and noul—over the same state in one call. @kentcdodds

• 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. @steipete
• The workflow works with Linux, macOS, and Windows boxes. @steipete CUA also works across them, which Steinberger says can make the agent more efficient than relying only on screenshots. @steipete

• 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. @steipete
• Practical tip: open the home sidebar and ask the claw to reorganize its sessions, using the agent itself to keep session history organized. @steipete