Twitter AI - 2026-09-24¶
1. What People Are Talking About¶
1.1 Coding-agent evaluation moved closer to real workflows 🡕¶
Dozens of non-retweets touched coding agents, eval design, or verifier quality, and the cluster was visibly denser than it was on 2026-09-23. The qualitative change mattered more than raw volume: instead of just posting leaderboards, people spent the day arguing about token budgets, tool fallback, memory injection, and whether public benchmarks resemble the environments agents actually work in.
@josevalim asked (101 likes, 25 replies, 5,441 views, 67 bookmarks) what happens to language communities, ergonomics, compilers, and tools if coding agents write most of the code. The linked Dashbit essay turned that into a concrete tooling agenda: program databases instead of document-position-oriented LSPs, and runtime observability/query interfaces instead of human step-through debuggers (article).
@ArtificialAnlys reported (128 likes, 19 replies, 7,188 views) that Claude Code with Opus 5.5 reached 66 on the Coding Agent Index, up from 60 for Opus 5, while cost per task rose to $13.04 because token use increased to about 15.6 million tokens per task. The attached chart mattered because it showed both sides of the argument at once: the day's highest public coding-agent score and the expensive end of the score-vs-cost frontier.
@DeepLearningAI summarized (34 likes, 5 replies, 2,400 views, 26 bookmarks) Meta AI's answer to context rot: pair the action agent with a separate memory agent that writes and retrieves short reminders instead of bloating the whole context window. The linked article added the hard numbers the tweet itself only teased: Claude Sonnet 4.5 rose from 37.6% to 45.9% on Terminal-Bench 2.0 and from 55.0% to 61.8% on Ï„2-Bench when the memory agent injected reminders at the right moments.
@dair_ai highlighted (14 likes, 4 replies, 2,061 views, 14 bookmarks) Salesforce's RIVER paper as a verifier-quality story rather than a brute-force data story. The linked summary is unusually specific: only 35.8% of the audited TMax environments were clean, 40.4% had overly weak verifiers, and River-8B still averaged 19.4 across four terminal benchmarks versus 17.7 for RL on a random 3.5K-environment sample (paper summary).
Discussion insight: The strongest pushback came from two directions at once. @pmddomingos wrote (64 likes, 11 replies, 2,545 views) that AI often aces a few benchmarks, declares victory, and leaves most of the real problems unsolved; then @morganlinton reported (21 likes, 13 replies, 1,701 views) a live measurement failure mode, where part of his Opus 5.5 eval suite was being refused by Claude Code's safety classifier and falling back to Opus 4.8. That shifted the day from "who is #1?" toward "what exactly are we measuring, at what budget, and with what hidden tool behavior?"
Comparison to prior day: On 2026-09-23, the evaluation conversation centered on benchmark infrastructure and long-horizon public suites. On 2026-09-24, it moved into the loop itself: memory injection, verifier audits, token budgets, and the runtime quirks that can silently contaminate a benchmark.
1.2 Decision models kept multiplying, but the verifier argument got sharper 🡕¶
The decision-model cluster was not dramatically larger than it was a day earlier, but it was more competitive and more technical. The discourse moved beyond explaining Jev into launching alternatives, indexing them, and arguing over what counts as a fair verifier comparison.
@jackyk02 introduced (544 likes, 22 replies, 32,316 views, 575 bookmarks) Contrastive Language Model as a fast System One release that separates state and action embeddings so they can be cached independently. The linked repo filled in the details: frozen Qwen3-8B encoders, 20M-parameter heads, 60M Nemotron Q&A pairs for pretraining, 30M synthetic hard negatives, 1M agent trajectories for post-training, and claims of 81.6% on DeepSWE and 87.6% on Terminal-Bench 2.1 when CLM is used as a verifier (repo).
@multimodalart updated (45 likes, 8 replies, 4,358 views, 34 bookmarks) Decision Index from 0.1 to 0.2 with a new formula, 29 more Jev-like models, and 21 more benchmarks, while naming AutoJev-27B the leading open model. That mattered less as a one-day leaderboard update than as evidence that the small typed-model niche now has enough entrants and enough evaluation variance to require its own ranking infrastructure.
Discussion insight: This part of the feed was no longer claiming that small decision models replace full LLMs. Instead, it kept converging on narrower jobs: rank candidate actions, route tools, score best-of-N trajectories, and serve as verifiers when the action set is bounded enough for caching and calibration to matter.
Comparison to prior day: On 2026-09-23, the Jev cluster was still dominated by cheat sheets, demos, and computer-use releases. On 2026-09-24, it shifted into direct competition over verifier speed, benchmark coverage, and the indexing layer around the whole category.
1.3 Cheap access plus local/open-weight performance moved from abstractions to concrete numbers 🡕¶
The local/open-weight cluster stayed smaller than the coding-agent discussion, but the evidence became much more concrete. Instead of generic "local AI" enthusiasm, people posted price-tier charts, cost-per-task tables, Apple-Silicon runtime deltas, and consumer-GPU long-context runs.
@cline announced (422 likes, 46 replies, 15,694 views, 83 bookmarks) that Gemini 3.8 Flash was free in Cline, then backed the pitch with a price-tier chart showing a 41 Intelligence Index score, ahead of similarly priced DeepSeek V4.1 Flash, GPT-5.6 Luna, and Qwen3.8 27B. The post framed competition in operational terms: 291 tok/s, 1M context, and a model that is cheap enough to expose broadly inside a developer tool.
@FellMentKE argued (140 likes, 16 replies, 53,856 views, 74 bookmarks) that Xiaomi's MiMo V2.6 Pro mattered because it combined a 46 Intelligence Index score with a weighted $0.13 cost per task. The three attached charts made the case legible: MiMo led the open-weight slice of the leaderboard, sat near the bottom of the cost table, and landed on the intelligence-cost Pareto frontier near much more expensive frontier systems.
@jundotkim released (33 likes, 4 replies, 1,724 views) oMLX 0.7.0rc1 with exact runtime improvements in public release notes: Qwen3.8-Flash-Next prefill rose from 1,522 to 2,007 tok/s on an M5 Max, Qwen3.8-27B DFlash decode rose from 56.9 to 131.5 tok/s, and one partial-block-caching change cut a next-turn prefill case from 1,174 tokens to 37 (release notes). At the cheaper end of the same story, @Oluwaphilemon1 showed (4 likes, 1 reply, 724 views, 6 bookmarks) MiMo-V2.6-Distill-Qwen-9B running with a 262K context window on a single 12GB RTX 3060 at about 47 tok/s decode and about 1,600 tok/s prefill.
Discussion insight: The feed kept treating local and sovereign AI less as a privacy slogan and more as a systems problem: token budgets, cache reuse, quantization, and whether a smaller model stays useful once you put it inside a real agent loop.
Comparison to prior day: On 2026-09-23, local-runtime talk was about packaged stacks and latency case studies. On 2026-09-24, it tightened around price-tier arbitrage, open-weight Pareto charts, and exact serving improvements on consumer and Apple hardware.
1.4 Agentic commerce talk shifted from flashy demos to incentive design and payment rails 🡕¶
The consumer-commerce cluster remained noisy, but the conversation got more specific about who the agent works for, how the checkout stack is wired, and what happens when autonomous transactions go wrong. That made the cluster more useful, because the hardest questions were no longer product demos but trust, merchant plumbing, and dispute handling.
@alex_verem argued (24 likes, 11 replies, 3,112 views) that Meta's Muse creates a structural incentive conflict if it stays free by taking a cut of each purchase. The post's core claim was not that the product is impossible, but that an agent holding logins, payment access, and merchant connections may optimize for checkout volume in ways the buyer cannot easily inspect.
@HiCagr described (15 likes, 3 replies, 1,804 views) Muse as an always-on per-user VM running headless browsers, frequent tool loops, a separate safety sentinel, and connectors spanning Gmail, Outlook, Plaid, OpenTable, Shopify, PayPal, Expedia, and Instacart. That pushed the conversation down a layer, from glossy consumer UX to the runtime and infrastructure load behind a real always-on agent.
@MiaRSato pushed back (9 likes, 4 replies, 417 views) that shopping, party-planning, and travel agents only make sense if you already dislike the activity itself. Her replies sharpened that into a taste problem: average recommendations may be fine for low-preference tasks, but they are a poor fit for style-heavy decisions where the user actually enjoys the search process.
@DhawalDoshi5 framed (13 likes, 1 reply, 684 views) Pine Labs × Google Cloud as merchant infrastructure for agentic commerce rather than another storefront assistant. The attached screenshots made the thesis concrete by naming discoverability, payment, and governance as the three barriers, then mapping them to Gemini Enterprise agents, Pine Labs' P3P payment layer, Jarvis, and UCP/A2A support.
Discussion insight: The most actionable answer to "how do agents buy things safely?" came from infrastructure posts rather than consumer demos. @d3rekson described (23 likes, 10 replies, 433 views) an Internet Court flow where disputes preselect a route, bundle evidence automatically, and use three different AI judges instead of a single model.
Comparison to prior day: On 2026-09-23, the feed already cared about the buy button and permission boundaries. On 2026-09-24, it focused much more explicitly on fee incentives, merchant plumbing, and dispute resolution.
2. What Frustrates People¶
Benchmarks still break when they meet real workflows¶
The loudest frustration was not that benchmarks are useless; it was that they still fail too often as operational decision tools. @pmddomingos said (64 likes, 11 replies, 2,545 views) the field keeps acing a few benchmarks and moving on while the actual problems stay unsolved; @ArtificialAnlys showed (128 likes, 19 replies, 7,188 views) that the best coding-agent score of the day also came with the highest cost per task; and @morganlinton ran into (21 likes, 13 replies, 1,701 views) a live measurement failure when Claude Code's safety classifier caused part of an Opus 5.5 suite to fall back to Opus 4.8. The RIVER audit gave the structural reason why this keeps happening: @dair_ai reported that only 35.8% of the cleanest audited public environment pool was actually clean.
Severity: High. The visible workarounds are private benchmark suites, cleaner verifier audits, matched-budget comparisons, and more workflow-shaped evaluation funding like @mercor announced (15 likes, 2 replies, 1,097 views, 8 bookmarks). This is worth building for because the community is no longer asking for a prettier leaderboard; it is asking for measurement it can trust under real toolchain conditions.
Long-horizon agents still get tripped up by memory, thresholds, and guardrails¶
A second frustration was that agents often fail on the control plane before they fail on raw reasoning. @DeepLearningAI summarized (34 likes, 5 replies, 2,400 views, 26 bookmarks) Meta's finding that long contexts cause agents to forget early mistakes, while @sakevoid wrote (9 likes, 8 replies, 551 views) that a Claude Code safety hook caught 26 of 27 dangerous commands and stayed stable across 239 prompt-injection cases, but "the model was stable. the thresholds weren't." @HiCagr added (15 likes, 3 replies, 1,804 views) the runtime version of the same problem: every tool loop grows context, increases compute load, and forces more safety checks before the agent even acts.
Severity: High. The workarounds today are separate memory agents, narrower reminder injection, explicit approval hooks, and more traceable receipts about what a memory or guardrail actually saw. This still looks worth building for because the pain appears across coding agents, consumer agents, and evaluation harnesses alike.
Commerce agents still have an alignment and governance problem¶
The third frustration was that autonomous buying flows still do not convincingly answer the question "who is the agent serving?" @alex_verem argued (24 likes, 11 replies, 3,112 views) that a purchase agent funded by transaction fees is economically aligned with merchants, not necessarily buyers; @MiaRSato argued (9 likes, 4 replies, 417 views) that some of the showcase shopping and travel use cases only help users who do not care much about the underlying choice; and @d3rekson described (23 likes, 10 replies, 433 views) an entire dispute-resolution layer because bot-to-bot commerce cannot rely on ordinary human courts for low-value transactions.
Severity: Medium-High. The current workaround is to add more explicit governance around the transaction itself, which is why @DhawalDoshi5 centered Pine Labs × Google Cloud around discoverability, payment, and governance rather than just another conversational UI. This is worth building for because the objections are not anti-agent; they are specific gaps in incentives, auditability, and user control.
3. What People Wish Existed¶
Workflow-grounded evals and verifiers teams can actually trust¶
The clearest need was for evaluation that survives contact with real stacks, real token budgets, and real workflow messiness. @dair_ai surfaced (14 likes, 4 replies, 2,061 views, 14 bookmarks) a verifier audit where most public environments were defective, @morganlinton hit (21 likes, 13 replies, 1,701 views) an unexpected Claude Code fallback while benchmarking Opus 5.5, and @mercor responded (15 likes, 2 replies, 1,097 views, 8 bookmarks) by funding work on reward calibration, realistic environments, long-horizon tasks, and ambiguous requests. This is a practical need, not an aspirational one: teams already have agents, but they do not yet have measurement they fully trust. Opportunity: direct.
Agent-native programming tools that expose code and runtime state cleanly¶
@josevalim made (101 likes, 25 replies, 5,441 views, 67 bookmarks) the strongest case that agent-era tooling should expose program databases and runtime observability rather than rely on LSPs and human-style debugging flows. The memory-agent posts pointed in the same direction from another angle: @DeepLearningAI showed (34 likes, 5 replies, 2,400 views, 26 bookmarks) that reminders help only when they are injected at the right moment, and the replies immediately asked for receipts, expiry, and traceability around those memories. This need is partially addressed by today's hooks, traces, and agent frameworks, but the feed still suggests the control surface is too fragmented. Opportunity: competitive.
Transaction rails that are aligned with the buyer, not just the merchant¶
The commerce posts kept circling back to the same missing layer: an agent should not only be able to buy, it should also be legible, governable, and dispute-ready. @alex_verem worried (24 likes, 11 replies, 3,112 views) about transaction-fee incentives, @d3rekson described (23 likes, 10 replies, 433 views) bot-to-bot dispute resolution as a missing trust layer, and @DhawalDoshi5 framed (13 likes, 1 reply, 684 views) discoverability, payment, and governance as separate infrastructure problems. This is an urgent practical need because the builders already assume agents will transact; they just do not yet agree on the rails. Opportunity: direct.
Local/open-weight stacks that stay cheap without becoming hard to operate¶
The open-weight cluster showed a quieter but very real wish: people want local or cheaper stacks that still feel first-class. @cline emphasized (422 likes, 46 replies, 15,694 views, 83 bookmarks) free access plus speed and context, @jundotkim focused (33 likes, 4 replies, 1,724 views) on serving gains and cache behavior, and @Oluwaphilemon1 treated (4 likes, 1 reply, 724 views, 6 bookmarks) a 12GB RTX 3060 run as meaningful precisely because it lowered the hardware bar. The need is not "one more model" so much as cheaper orchestration, caching, and deployment surfaces around the models people already want to use. Opportunity: competitive.
4. Tools and Methods in Use¶
| Tool | Category | Sentiment | Strengths | Limitations |
|---|---|---|---|---|
| CLM-8B | Decision model | (+/-) | Separate state/action caching, typed decisions, strong reported verifier results on DeepSWE and Terminal-Bench 2.1 | Early release, fairness of Jev comparisons is still debated, broader independent validation is limited |
| Jev / Decision Index | Benchmark/index layer | (+/-) | Shared reference point for many small decision models and use cases | Formula and benchmark coverage are still moving, and long-horizon verifier fit is disputed |
| Claude Opus 5.5 in Claude Code | Coding agent model | (+/-) | Highest public coding-agent score of the day and gains across three evaluations | Highest cost per task in the comparison, heavy token use, and some suites hit safety-classifier fallback |
| Gemini 3.8 Flash in Cline | Coding model | (+) | Free in-tool access, 291 tok/s, 1M context, strong price-tier positioning | Evidence is strongest inside one tool context rather than across many public workloads |
| MiMo V2.6 Pro / Distill-Qwen-9B | Open-weight reasoning model | (+) | Strong intelligence-cost frontier, multimodal story, and practical small-GPU experimentation | Real agent-loop usefulness is still being tested beyond benchmark and local-run claims |
| oMLX 0.7.0rc1 | Local inference runtime | (+) | Faster prefill/decode, partial block caching, and fresh MiMo multimodal support | Release-candidate maturity and a setup that still leans toward Apple/MLX-oriented users |
| RIVER | RL training recipe | (+) | Improves verifier quality and generalization with fewer environments | Depends on expensive environment audits and oracle filtering |
| Claude Code safety hook | Guardrail method | (+/-) | Strong dangerous-command blocking and prompt-injection resistance in one public build | Threshold tuning is brittle and policy design remains manual |
| Muse | Consumer agent runtime | (+/-) | Broad connectors, dedicated per-user runtime, and background task execution | Incentive alignment, taste fit, and dispute handling remain unresolved |
| Pine Labs P3P / Jarvis | Commerce infrastructure | (+/-) | Separates discoverability, payment, and governance into explicit merchant rails | Still partnership-stage and integration-heavy rather than broadly proven |
Overall satisfaction split by layer rather than by brand. @ArtificialAnlys reported (128 likes, 19 replies, 7,188 views) a clear score/cost tradeoff for frontier coding agents, while @cline marketed (422 likes, 46 replies, 15,694 views, 83 bookmarks) a much cheaper access tier. On the open-weight side, @FellMentKE used charts to make MiMo's economics legible, and @jundotkim published exact serving deltas instead of vague local-AI enthusiasm.
The most common workaround pattern was to separate layers: use a stronger but pricier frontier coding model for difficult tasks, route or verify with smaller typed models, push cheaper/open models into local experimentation, and bolt on extra control surfaces such as memory agents, safety hooks, or merchant-governance rails. The competitive dynamic that stood out was not one model replacing another; it was runtimes, eval harnesses, and transaction layers competing to shape which model gets used where.
5. What People Are Building¶
| Project | Who built it | What it does | Problem it solves | Stack | Stage | Links |
|---|---|---|---|---|---|---|
| CLM-8B | @jackyk02 / Contrastive-LM | System One model and API for typed decisions, ranking, and verifier selection | Makes fast routing and verification cheaper than using a full generative model for every bounded decision | Qwen3-8B embedding backbones, contrastive heads, vLLM, TypeSafe-compatible API | Alpha | tweet, repo |
| Decision Index 0.2 | @multimodalart | Ranking space for Jev-like decision models across size, speed, and use case | Gives builders a common comparison layer for a fragmented small-model niche | Hugging Face Space, benchmark aggregation, model-index formulas | Beta | tweet, space |
| oMLX 0.7.0rc1 | @jundotkim | Local inference runtime with faster Qwen/MiMo serving and better cache reuse | Reduces the latency and wasted recompute that make local/open-weight stacks harder to use | MLX, Metal, DFlash, Lightning MTP, partial block caching, MiMo sidecars | Beta | tweet, release |
| Pine Labs Jarvis / P3P | Pine Labs / Google Cloud | Merchant-side agentic-commerce platform spanning discovery, payments, and governance | Lets merchants participate in AI-driven buying without rebuilding checkout and compliance from scratch | Gemini Enterprise Agent Platform, P3P payment rail, Jarvis multi-agent platform, UCP/A2A support | Beta | tweet |
| GPTZero 4o | GPTZeroAI / @alexcdot | AI-detection model tuned for low false positives and stronger robustness to edits and paraphrases | Helps schools and other evaluators distinguish human writing from AI-assisted or AI-generated text | Detection model plus third-party benchmark evaluation on DetectRL and related suites | Shipped | tweet |
| SmolDataEnvs | @adithya_s_k | Open 5K+ task set of verifiable RL environments for code and data science | Gives small-model training and eval loops a public source of structured, checkable tasks | Open-source environments, eval sets, and training data | Alpha | tweet |
CLM, Decision Index, and SmolDataEnvs all point at the same builder pattern: people are productizing the control and evaluation layer around agents, not only the base models. CLM packages typed routing and verification, Decision Index packages category-level comparison, and SmolDataEnvs packages open tasks that can be used to train or check smaller agentic models.
A second build pattern is local-runtime optimization as product surface. oMLX is not selling a new model; it is selling faster prefill, faster batched decode, and better cache behavior so that open-weight models feel usable on local hardware. That is the same pressure visible in the MiMo-on-3060 experiments and the free-in-tool Gemini positioning: the model matters, but the serving layer increasingly determines whether it is practical.
Pine Labs and GPTZero broaden the picture rather than contradict it. Pine Labs is building transaction and governance rails around agentic commerce, while GPTZero is building a detection layer around AI-written output. In both cases, the product is not just the model response; it is the operational system that decides whether a model can be trusted in production.
6. New and Notable¶
GPTZero 4o pushed AI detection back into the benchmark conversation¶
@alexcdot released (15 likes, 3 replies, 510 views) GPTZero 4o as a detector tuned for extremely low false positives, claiming fewer than one in 10,000 human passages are mislabeled as AI while still detecting Claude Fable at 98.4%. The attached chart mattered because it broke the claim down across overall average, multi-domain, multi-LLM, attack, and human-writing cases instead of leaving it at one headline number.
Mercor turned benchmark complaints into a funded program¶
@mercor announced (15 likes, 2 replies, 1,097 views, 8 bookmarks) a $5M AI Capabilities Fund for reward calibration, realistic environments, long-horizon workflows, ambiguous requests, and business/social context. That was notable because it converted a repeated feed complaint—"our evals do not reflect how models are used"—into a concrete budget line with researcher time, API credits, travel, access to Mercor's expert network, and use of its eval platform.
SmolDataEnvs made small-model RL feel more buildable¶
@adithya_s_k released (5 likes, 1 reply, 160 views) SmolDataEnvs as 5K+ verifiable RL environment tasks for code and data science, fully open across environments, evals, and training. It is notable less because of raw reach and more because it matches the day's broader turn toward smaller, cheaper, more checkable agent loops.
7. Where the Opportunities Are¶
[+++] Workflow-grounded eval and verifier tooling — This was the strongest cross-section signal of the day. RIVER's environment audit, Opus 5.5's score-vs-cost tradeoff, Morgan Linton's safety-fallback benchmark problem, and Mercor's $5M fund all point at the same gap: teams need evaluation that matches the actual harness, budget, and workflow they deploy.
[+++] Local/open-weight runtime optimization — Cline, MiMo, the 12GB RTX 3060 run, and oMLX all made the same opportunity legible from different angles: the market wants cheaper inference and long context without giving up usability. The product surface here is not just the model weights; it is routing, caching, quantization, and serving ergonomics.
[++] Agent-native development observability and memory control — Jose Valim's essay, Meta's memory-agent pattern, and the Claude Code safety-hook experiments all suggest a gap above the model layer. Better program databases, runtime queries, memory receipts, and guardrail traces would help agents debug, recover, and stay auditable.
[++] User-aligned transaction rails for commerce agents — Muse's incentive debate, Pine Labs' explicit discoverability/payment/governance split, and Internet Court's dispute layer all show that agentic commerce needs more than checkout automation. The opportunity is in the trust rails that determine whether users and merchants will let agents transact repeatedly.
[+] Detection and provenance systems for AI-written output — GPTZero 4o shows there is still appetite for classifiers that reduce false positives while staying robust to edits and paraphrases. This looks like an emerging but narrower opportunity than the infrastructure categories above, because it depends on who still needs machine judgments about authorship and compliance.
8. Takeaways¶
- Evaluation moved from leaderboard theater toward workflow fit. @ArtificialAnlys reported (128 likes, 19 replies, 7,188 views) that Opus 5.5 set the top coding-agent score but at the highest cost per task, while @dair_ai reported (14 likes, 4 replies, 2,061 views, 14 bookmarks) that only 35.8% of the cleanest audited public environments were actually clean.
- Small decision models are increasingly defined by routing and verifier jobs, not by general chat behavior. @jackyk02 introduced (544 likes, 22 replies, 32,316 views, 575 bookmarks) CLM as a cached state/action scorer, and @multimodalart updated (45 likes, 8 replies, 4,358 views, 34 bookmarks) the indexing layer around that niche with 29 more Jev-like models and 21 more benchmarks.
- Open-weight and local AI kept gaining credibility because the numbers got concrete. @cline showed (422 likes, 46 replies, 15,694 views, 83 bookmarks) a free high-speed price-tier model inside Cline, @FellMentKE showed (140 likes, 16 replies, 53,856 views, 74 bookmarks) MiMo-V2.6-Pro at 46 and about $0.13 per task, and @jundotkim published (33 likes, 4 replies, 1,724 views) exact oMLX serving gains.
- Long-horizon agent quality now depends heavily on the memory and guardrail layer around the model. @DeepLearningAI reported (34 likes, 5 replies, 2,400 views, 26 bookmarks) a memory-agent lift from 37.6% to 45.9% on Terminal-Bench 2.0, while @sakevoid reported (9 likes, 8 replies, 551 views) that a Claude Code safety hook mostly worked but its thresholds still did not.
- Agentic commerce discourse got more serious by focusing on incentives and rails, not just UX. @alex_verem argued (24 likes, 11 replies, 3,112 views) that transaction-fee economics can misalign a shopping agent with the buyer, while @DhawalDoshi5 showed (13 likes, 1 reply, 684 views) Pine Labs splitting the problem into discoverability, payment, and governance, and @d3rekson added (23 likes, 10 replies, 433 views) a dispute-resolution layer on top.
- Builders kept shipping infrastructure around models instead of only shipping more models. @mercor funded (15 likes, 2 replies, 1,097 views, 8 bookmarks) new eval work, @adithya_s_k released (5 likes, 1 reply, 160 views) open RL environments, and @alexcdot released (15 likes, 3 replies, 510 views) a new detection model.