GLM‑5‑Turbo lists at $0.96/$3.20 per Mtok – 202K context for agents

GLM-5-Turbo (Z.ai): Z.ai introduced GLM-5-Turbo as a high-speed variant of GLM-5 tuned for agent-driven workflows like OpenClaw (tool invocation, long chains, and persistent tasks), as described in the launch thread. Availability is staged—Pro users in March and Lite users in April—per the rollout schedule post.

Z.ai also pointed people to early-access forms for both tiers in the early access note. Details are still evolving. It shipped quickly.

GLM-5-Turbo (Z.ai via OpenRouter): GLM-5-Turbo is now listed on OpenRouter with $0.96/M input and $3.20/M output, plus a 202,752-token context window, as shown in the pricing card screenshot and reflected on the OpenRouter listing.

The listing frames it as optimized for long execution chains and tool use, which matches the positioning in the launch thread. Pricing is now concrete. Latency and reliability will depend on providers.

GLM-5-Turbo (BridgeBench): BridgeMind reports GLM-5-Turbo ranked #18 on BridgeBench with 80.2 overall, 76.9% completion, and notably lower UI and security subscores (50.9 UI; 63.5 SEC), as shown in the benchmark table screenshot.

The same post claims it trails GPT-5.4 by ~15 points and Claude Opus 4.6 by ~14, per the BridgeBench summary. This is one benchmark snapshot. It’s not an official eval artifact from Z.ai.

GLM-5-Turbo (Z.ai): Z.ai says GLM-5-Turbo is an experimental release and is currently closed-source, with capabilities and findings intended to roll into the next open-source model, per the closed-source note. This is explicit. It constrains self-hosting.

Rollout timing still follows the Pro/Lite schedule described in the launch thread. What lands in open weights remains unspecified.

Crush (Charm): Charm says GLM-5-Turbo is immediately selectable in Crush with “no update required,” per the availability post.

The screenshot shows it in the Z.ai model list inside Crush’s “Switch Model” UI, marked as configured in the model picker view. It’s a distribution win. It reduces friction for trying the new model.

GLM Coding Plan (Z.ai): Z.ai says usage limits are tripled for GLM-5-Turbo during non-peak hours, with access excluded from 2–6 AM ET and the promo ending April 30, per the limits update. This is a quota change. It affects sustained agent runs.

No new pricing detail accompanied the change. It’s a capacity signal.

GLM-5-Turbo (Z.ai): The docs emphasize GLM-5-Turbo being trained around OpenClaw-style agent requirements—tool invocation, command following, timed/persistent tasks, and long-chain execution, as shown in the docs excerpt screenshot and described in the launch thread.

The linked guide also positions it for agent integration via Z.ai APIs, with entry points collected in the API docs link set. The spec language is agent-first. Benchmarks are coming from third parties for now.

GLM-5-Turbo (OpenRouter providers): Screenshots of OpenRouter’s provider stats show large swings for GLM-5-Turbo—one snapshot shows 2.06s latency and 87 tps in the provider stats view, while another shows 2.82s latency and 30 tps in the later stats screenshot.

Community reaction includes confusion about “turbo” speed when throughput dips, as captured in the throughput complaint. These are point-in-time measurements. They may reflect routing, load, or prompt mix.

OpenClaw + Ollama (Ollama): OpenClaw added Ollama as an official auth/provider path, with a guided flow triggered by openclaw onboard --auth-choice ollama and the claim that “all models from Ollama will work” in OpenClaw workflows, per the Provider announcement.

The practical change is fewer glue steps for teams already standardizing on Ollama (local or cloud) and wanting to run the same agent surfaces without bespoke adapters, as shown in the Provider announcement.

vLLM + OpenClaw (vLLM Project): A short recipe shows OpenClaw working with a self-hosted model by deploying it with vLLM, exposing an OpenAI-compatible API, then pointing OpenClaw at that endpoint—claiming tool calling works “out of the box,” per the vLLM setup guide.

Video loads on view

This is a clean operational pattern for teams that want OpenClaw’s agent loop/UI while keeping model serving local or on their own infra, as demonstrated in the vLLM setup guide.

Mentions hygiene (OpenClaw): Peter Steinberger reports an OpenClaw-powered cron that runs every 5 minutes and blocks “spam/reply guy/promo” mention accounts, saying it made replies useful again in the Mentions cleanup thread.

The concrete artifact is a daily digest showing 56 blocked profiles plus structured rationales (account signals + behavioral patterns), as shown in the Mentions cleanup thread, which is the kind of operational feedback loop that’s hard to get from manual moderation.

KiloClaw (Kilo Code): KiloClaw published pricing for its hosted compute layer—$49/month, “zero markup on AI tokens,” and “500+ models,” with an early-bird $25/month for 6 months for the first 1,000 users, per the Pricing announcement.

The launch timeline is also spelled out: “Free trial starts tomorrow” and charges begin March 23, as stated in the Pricing announcement and detailed on the Pricing page.

OpenClaw plugins (OpenClaw): Steinberger says he’s working on making plugins “more powerful” while keeping the OpenClaw core lean, and explicitly calls out planned support for Claude Code/Codex plugin bundles, per the Plugin roadmap note.

He also signals near-term movement by asking for a PR while “about to land this,” as shown in the PR request, which suggests plugin surfaces/APIs are actively being reshaped rather than just discussed.

OpenClaw vs alternatives (community): A blunt take—“Openclaw is bloatware now… switched to Hermes”—circulated via the Bloatware claim, reinforcing a recurring ecosystem tension between feature-rich agent runners and minimal “aesthetic” setups.

The same thread cluster includes claims that Hermes offers a migration script for OpenClaw users, as referenced in the Migration script mention. It’s sentiment, not a measured benchmark, but it’s the kind of narrative that influences tool adoption and contributor attention.

OpenClaw community (events): Photos and posts from a San Francisco OpenClaw robotics hackathon (Shack15) surfaced, showing an in-person builder cluster forming around OpenClaw, per the Hackathon post and follow-ups like the IRL hackathon update.

The visual signal includes attendees posing with a Unitree humanoid outfitted with boxing gloves, as shown in the Robot photo, which fits the pattern of OpenClaw positioning as an “always-on” agent runner people try to connect to physical systems.

Claude Agent SDK (Anthropic): Anthropic’s compliance docs state that OAuth tokens from Claude Free/Pro/Max are only for Claude Code and Claude.ai, and that using them in “any other product, tool, or service — including the Agent SDK” is not permitted, as quoted in the Compliance excerpt and detailed in the Legal and compliance docs. This matters for anyone building local wrappers, parallel runners, or “Claude Code but scripted” tooling, because the boundary between “using Claude Code” and “using the SDK” is exactly where ToS risk shows up.

Agent SDK guidance (Anthropic): An Anthropic employee acknowledges the situation is confusing and says they’re working on clearer guidance for the Agent SDK, as stated in the Anthropic acknowledges confusion reply. In a longer follow-up, they attribute some of the gaps to “incredible growth since January” and explicitly concede they “have not done fully right by Agent SDK users,” according to the Growth and triage context comment.

Auth boundary confusion: A builder asks Anthropic to clarify whether a subscription OAuth token can power the Claude Agent SDK “strictly for using Claude Code in a local dev loop” (including parallelizing multiple Claude Codes), and whether an open-source tool that enables this pattern can be distributed, as laid out in the Agent SDK auth questions thread. The same thread drills into what counts as “Claude Code automation” (bash scripting) versus “another product/tool” (TypeScript + SDK), highlighting why engineers are stuck choosing between a supported abstraction and a potential ToS violation, per the Script vs SDK nuance follow-up.

Claude Code workflow: A micro-automation pattern is to start Claude Code automatically in each new terminal by appending claude to your shell config (e.g., ~/.zshrc), as shown in the Auto-start tip screenshot.

This is presented as a “notice friction → ask Claude to fix it → repeat” loop, with a lightweight endorsement from another builder in the Reply reaction response.

Operational pattern: A concrete proposal is to name one person as the directly responsible individual for Agent SDK/compliance questions (“send all your questions my way”), on the theory that visible ownership reduces speculation and speeds up resolution, as argued in the Request a DRI post. For teams integrating Claude Code into internal tooling, this is the kind of governance mechanism that can unblock adoption when docs, product UX, and community statements drift out of sync.

GPT‑5.4 in Codex (OpenAI): A builder report says GPT‑5.4 frequently “stops early” on long tasks even with clear guidance, with missing leftovers only surfacing during code review, as described in the Long-run reliability complaint. The same post claims Cursor’s harness behaves better on similar work, and points to OpenAI Symphony as an approach that makes completion verifiable rather than assumed, as noted in the Symphony verification angle.

• Counter-signal: another practitioner says they’ve run GPT‑5.4 “non stop” since launch inside RepoPrompt (Codex app server under the hood) without these issues, suggesting harness + prompting differences may dominate, per the No issues report.

Codex UX (OpenAI): A power user describes a daily pattern of one “main” Codex chat plus separate chats per issue/feature, but says today’s UX makes the “main chat” no more prominent than any other thread—causing token waste as sessions repeatedly rediscover repo state, per the Codex chat history critique. The post calls for an orchestrator that can reference other threads by default, manage pins for undeployed work, and still allow isolation when needed.

The immediate takeaway is that multi-threaded agent work is now blocked by UI primitives (thread list, pins) rather than model capability.

Agent harness engineering: One explanation for why Cursor can feel more reliable than Codex is that Cursor appears to do deeper context building: codebase indexing (grep + semantic search + LSP graph), persisting long tool/MCP outputs to files instead of truncating, and model-specific instructions/tools tuned per provider, as laid out in the Cursor harness hypothesis. The same post speculates about multi-model worker/orchestrator setups that use a fast model to gather context and a stronger model to refine.

This frames “better coding agents” as a product of retrieval + tool-output persistence + prompt/tool tuning, not just raw model quality.

Model selection in practice: One practitioner claims GPT‑5.4 is stronger than Opus 4.6 for pure coding—better with edge cases, security, and plan-following—while also saying Claude Code still wins on developer experience for CLI workflows (requirements gathering, slash commands, plugins, customization), per the Coding vs DX comparison.

This keeps showing up as a two-axis choice: code quality vs harness ergonomics. The tweet is anecdotal, but it matches how teams increasingly route tasks by “what fails less” rather than by one overall favorite model.

Codex org signal (OpenAI): An OpenAI engineer says the Codex team repeatedly asks how to make the system “an order of magnitude better every few months,” citing past bets like the Codex App and an early deployment of Cerebras inference with WebSockets, as described in the Culture note. They add they’re “well under way” on a next bet that makes even top engineers nervous.

This is a signal about iteration tempo: the perceived bottleneck is end-to-end stack work (app, inference transport), not just model training.

Codex app promo (OpenAI): A community tracker site advertises “around the clock 2× usage across all Codex surfaces for paid plans,” with a countdown timer and a deadline of April 2, 2026, shown in the Promo screenshot.

It’s not an official OpenAI post in this dataset, so treat the details as unverified until corroborated elsewhere, but it’s already shaping expectations around rate limits and the Codex app’s paid tiers.

litter (community): A community-built “native mobile client for Codex” is being recommended as a way to use Codex remotely on iOS/Android via SSH until OpenAI ships official mobile support, per the Mobile client endorsement. The repository describes platform-specific apps (Kotlin/Swift) plus shared components and setup steps, as documented in the GitHub repo.

This matters for teams relying on long-running Codex sessions: it’s an early pattern for “phone as a window into the agent,” without waiting for first-party clients.

Codex × Notion (OpenAI, Notion): OpenAI Devs is promoting an in-person event at Notion’s NYC HQ on March 17 focused on Codex demos and practical workflows, as announced in the NYC event invite.

Video loads on view

More specifics (agenda, speakers, registration mechanics) are outlined on the Event page. It’s a notable signal that Codex is being positioned as something teams can operationalize, not only a model you try in isolation.

OpenAI Symphony (OpenAI): Community questions suggest Symphony adoption is still unclear—one person asks how many people are using it in the Usage check, followed by a practical question on how teams are building evaluations for real-time APIs in the Realtime eval question.

The open gap is measurement: once latency and streaming behavior change, offline “prompt → output” eval harnesses stop matching production behavior, and teams need new ways to score partial outputs, interruptions, and tool-call timing.

Diff-based review prompting (doodlestein): When requesting revisions from multiple frontier models, the workflow explicitly asks for “git-diff style changes” so the model morphs the existing document instead of rewriting from scratch and dropping sections, as explained in the Diff prompt rationale and further clarified in the Why diffs help.

The same diff framing is then used to merge competing model feedback into a single hybrid revision, with the “best-of-all-worlds” synthesis step happening inside one model after ingesting the other models’ diff suggestions, per the Diff prompt rationale.

Instruction salience (Uncle Bob): A concrete reminder that agents tend to optimize for “the last thing you told it,” while the “second-to-last” and “third-to-last” instructions degrade quickly—so rules placed early (including in CLAUDE.md / AGENTS.md) become less likely to be followed as the session evolves, per the Recency warning. This maps to a practical failure mode: teams encode policies once, then assume the agent will keep applying them while the working set shifts.

The operational implication is that “rules as context” behave like a fading cache; if a constraint matters, it needs periodic re-assertion or a harness-level enforcement mechanism rather than relying on initial text staying salient, as warned in the Recency warning.

Spec-driven development (ecosystem debate): Pushback argues that treating specs/plans as a substitute for reading code will “hard land” within 6–8 months; the critique is that high-level describe/plan/breakdown workflows help, but most of the value still comes from context engineering and grounding in the actual codebase, as laid out in the Spec skepticism and amplified in the PRD jab.

A related one-liner captures the boundary condition for agents: “you cannot outsource the thinking,” per the Can’t outsource thinking. The common thread is that specs are a control surface, not an immunity shield against drift.

Autoresearch workflow (practice signal): The emerging takeaway is that autoresearch-style work benefits less from elaborate agent infrastructure and more from a minimal system that can “throw more tokens” at the problem, as stated in the Autoresearch takeaway.

A useful counterweight is that this still depends on a well-posed harness/contract: the observation that “tasteful constraints… channel the compute” shows up in the Harness constraints note, where the harness defines metrics/timeouts/policies so the extra tokens are pointed somewhere measurable.

Planning-as-a-system (doodlestein): A detailed planning workflow uses repeated critique passes (“5x: look over everything for blunders…”) interleaved after each substantive plan expansion; the claim is that each pass keeps finding new omissions until it converges, as shown in the Planning workflow thread and reiterated in the Why repeat 5x.

The repeat-until-stable loop is paired with “invert the analysis” prompts (what guarantees let you do things the reference system can’t) and with making the plan self-contained enough to hand to other models—so the plan becomes a portable artifact, not just a chat transcript, per the Planning workflow thread.

Verification work (Uncle Bob): Multiple notes emphasize that agent help speeds implementation, but the slow part remains making the application “perfectly solid,” and that real leverage comes from guiding the model through debugging and hardening—not from initial codegen, as argued in the Hardening reality and reinforced by the Skill to guide debugging.

A related nuance is that refactoring “cleanup tools” don’t automatically translate to tests: after heavy mutation/cleanup, he reports the agent itself flagging tests as a “hodge-podge of uncorrelated assertions,” pushing toward restructuring test suites as a different kind of work, per the Tests need restructuring.

Prompting practice (Mitchell Hashimoto): Hashimoto describes deliberately forcing himself to learn how to prompt an agent to produce results at his own quality level, accepting that it’s initially “more than double the work” and slower, per the Hashimoto quote. The emphasis is on skill-building (closing the gap between what you’d write and what the agent produces), not on raw throughput.

Video loads on view

Agentic engineering (Simon Willison): Willison added a new introductory chapter defining “agentic engineering” as building software with coding agents that can both write and execute code in a loop, drawing a line between production-oriented practice and “vibe coding,” as described in the New guide chapter and expanded in the Guide chapter. It reads like an attempt to standardize vocabulary for tool-using agents (Codex/Claude/Gemini CLIs) so teams can talk about reliability patterns instead of debating vibes.

The chapter also functions as a concise “what to optimize” list: tool access, feedback loops, and verification steps—useful framing after the earlier fireside material on the same guide, following up on Agentic engineering with an explicit definition and scope.

Model mode behavior (ChatGPT): There’s a visible split between people who see Auto mode as underusing the system (“restrain me from telling her to turn on Thinking mode”), as said in the Plane mode complaint, and people who report using Auto/Instant for most turns (“70% of turns”), as stated in the Auto usage share. Another datapoint is that some users switch based on task type—Auto for learning/“higher EQ,” but a heavier mode for search/data science—per the Task-based mode choice.

The net signal is that “mode selection” is now part of workflow culture, and teams will end up with implicit norms and expectations about latency/cost vs thoroughness even before they write them down, as shown in the Surprised reaction.

Tooling ergonomics (community signal): A short warning—“do not adopt any new code editors this month”—captures how fast agent IDEs and coding environments are shifting, and how easy it is to burn time migrating setups mid-wave, per the IDEs of March quip.

It’s not a product update, but it does reflect a constraint AI teams keep hitting: when the environment is changing weekly, “switching cost” becomes a real part of the engineering budget—even if models are improving.

ACE (aceagent): ACE has been open-sourced with a new self-host path, shifting it from a hosted workflow tool into something teams can run alongside their agent stacks, as announced in Open-source announcement with setup details in the linked GitHub repo.

• What it’s for: the repo frames ACE as “agentic context engineering”—turning prompts into evolving playbooks that capture wins/failures and reduce repeated agent mistakes, per the GitHub repo.
• Ops shape: self-host instructions are Docker-first (Postgres/Redis/FastAPI), keeping the hosted service as an option, according to Open-source announcement.

Collaborator (collaborator-ai): Collaborator is being pitched as an end-to-end environment for agentic development—terminals, context files, and running code laid out on an infinite canvas—per Product demo post and the linked GitHub repo.

Video loads on view

The public repo describes a macOS (arm64) desktop app that stores data locally and bundles a modern editor stack (Electron/Monaco) to reduce “tab hunting,” matching what’s shown in Product demo post.

supermemory (supermemory): supermemory introduced a CLI intended to make agents “first-class users,” where anything available in the platform can be executed via an agent prompt, as described in CLI launch post; it also adds scoped API access (tag-scoped permissions, read/write controls) plus audit logs for agent actions, per Scoped access details.

Video loads on view

The positioning is explicitly “CLI over MCP for power,” while still acknowledging MCP isn’t going away, as stated in CLI launch post.

Emdash (emdashsh): Emdash added “review presets,” letting you configure a default review agent + prompt and start a review chat for a task without retyping the same instructions, as shown in Preset feature demo.

Video loads on view

This is a small UX change, but it formalizes “default reviewer” configuration as a product surface rather than a copy/paste habit, matching the flow in Preset feature demo.

Portless (Vercel Labs): Portless is now available on Windows via npm install -g portless, extending its “named URLs instead of port numbers” local-dev workflow to Windows-based teams, as announced in Windows availability note with project specifics in the linked GitHub repo.

The repo description emphasizes stable .localhost naming, proxying, and workflow support such as git worktrees, per GitHub repo.

Skillflag (CLI convention): A draft spec proposes a --skill flag that any CLI can implement to expose installable “skill directories” (not just single prompt files); it centers on discovery via --skill list and export via --skill export <id> streaming a tar bundle to stdout, as shown in the Spec screenshot.

The proposal is intentionally agent-tool-agnostic (meant to be adapted by separate installers), which targets the current portability gap where every tool reinvents its own skills packaging and install paths.

Warp (Terminal): Warp now shows “Universal (.agents/skills) — always included” targets spanning multiple agent clients (Amp, Cline, Codex, Cursor, Gemini CLI, OpenCode, Warp), alongside additional per-tool install locations, as shown in the Installer targets UI.

This is an explicit move toward a shared filesystem convention for skills distribution, reducing per-tool installer logic.

CLI-Anything (HKUDS): The repo is showing rapid adoption—one post calls out “15K stars already,” framing CLIs as a strong interface for coding agents, in the Stars and CLI note. The project positions itself as a framework to make existing software “agent-ready” by generating unified CLIs and plugin installs, as described in the GitHub repo.

json-render (Vercel Labs): A Solid.js integration is now available as an installable skill, using npx skills add vercel-labs/json-render --skill solid per the Install command. The underlying component catalog and schema-driven UI approach are outlined on the Project site.

Hermes Agent (Nous Research): Hermes has a built-in /background command to run a prompt asynchronously—documented inline as “Run a prompt in the background (usage: /background <prompt>)” in the Command hint screenshot.

It’s a small UX affordance, but it maps directly onto long-running agent workflows where foreground token streaming isn’t always the right default.

Language model teams as distributed systems (arXiv): A new paper frames multi-agent LLM setups as classic distributed systems—predicting the same pain points (O(n²) communication overhead, straggler delays, and consistency conflicts) and measuring how different coordination structures trade off progress vs resilience, as summarized in the Paper screenshot.

The empirical takeaway in the Paper screenshot is that decentralized teams can waste rounds communicating but can recover faster when individual agents stall, which gives agent builders a more principled way to choose team size and orchestration topology than “add more agents and hope.”

OpenClaw-RL (Gen-Verse/Princeton): Following up on Train by talking (continuous RL from interactions), today’s thread breaks the learning signal down into two next-state channels—evaluative feedback (good/bad) and directive hints (what to do instead)—in the Two signal types explainer.

• Async system design: The training loop is described as four parallel components—policy serving, environment/interaction collection, PRM judging, and policy training—so updates happen continuously without blocking user traffic, per the Four components and Async loops posts.
• Token-level correction: The directive path is framed as Hindsight-Guided On-Policy Distillation (OPD), where “what should have happened” is used to generate a teacher distribution and derive token-level gradients, as outlined in the How OPD works thread.

Primary artifacts are linked via the ArXiv paper and the GitHub repo.

AgentRank (HyperspaceAI): An AgentRank release announcement positions a PageRank-like scoring system for autonomous agents, where endorsements are anchored to cryptographically verified work to make sybil attacks expensive, as introduced in the AgentRank announcement and detailed on the Paper site.

The core claim on the Paper site is that “trust” becomes a network property computed from a delegation graph, with mechanisms like recency decay and penalties for sybil clusters, aiming to support peer-to-peer agent ecosystems where you need a non-handwavy way to choose which agents to rely on.

Intelligent AI Delegation (Google DeepMind): DeepMind published a framework that treats delegation as a sequence of decisions—whether to delegate, how to specify roles/boundaries, how to transfer authority/accountability, and how to verify results—rather than a one-shot “tell the agent and pray,” as described in the Delegation paper summary.

Beyond the high-level protocol, the Delegation paper summary explicitly points toward mechanisms like formal trust models (to prevent over/under-delegation) and verification approaches (including cryptographic proofs / skill certificates) to make multi-party delegation networks more robust.

Agent memory architectures: A roundup thread enumerates seven emerging approaches—Agentic Memory (AgeMem), Memex, MemRL, UMA, Pancake, Conditional memory, and a “multi-agent memory from a computer architecture perspective” framing—capturing how quickly “memory” is becoming its own design space for agents beyond a single vector DB pattern, as listed in the Memory architectures list and amplified in the Retweet list.

MRCR v2 long-context retrieval: Sonnet 4.6 is shown scoring 65.1% on the 8-needle MRCR v2 variant at 1M tokens, extending the retrieval discussion from MRCR chart (Opus leading at 1M) with a second Claude-family datapoint in the plot shared in Retrieval accuracy plot.

• Relative positions at 1M: The same figure shows Opus 4.6 at 78.3%, versus GPT-5.4 Pro at 36.6% and Gemini 3.1 Pro at 25.9%, as labeled directly in Retrieval accuracy plot.

The chart is a retrieval-quality reminder: larger context windows don’t help much if needle retrieval collapses at full length.

Website Arena (benchmark): A Website Arena snapshot shared today puts GPT-5.4 at Elo 1298, with a blunt takeaway that it “can code” but “can’t design,” per the scorecard commentary in Website Arena chart; the same post notes it sits 79 points behind Claude Opus 4.6 at the top of that board.

This is a useful reminder that “good at coding” and “good at web UI” can diverge; this specific claim is benchmark-scoped rather than a general capability statement, and it depends heavily on the harness and judging rubric used in Website Arena.

BridgeBench Creative HTML (benchmark): A side-by-side run using the “same prompt” across GPT-5.4, Claude Opus 4.6, Gemini 3.1 Pro, and Grok 4.20 Beta is presented as a head-to-head comparison, with the montage calling GPT-5.4 the winner in the final frame, as shown in Winner montage.

Video loads on view

Treat this as a single test case unless you have the underlying prompt + judging artifact; it’s still a useful directional signal for teams tracking HTML/CSS/UI generation quality across frontier models.

Creative writing + EQ-Bench (leaderboards): A leaderboard snapshot circulating today places GPT-5.4 at the top of a “creative writing” rubric table, while separate chatter claims it ranks 3rd on EQ-Bench behind Claude models, as summarized in Results snippet and visually backed by the table screenshot in Creative writing table.

This is signal for teams choosing a default “writing” model, but it’s leaderboard-dependent; the same posts don’t include a canonical eval pack or prompt set to reproduce the exact ordering.

Grok 4.20 Beta (xAI): A performance roundup frames Grok as strong on throughput—around 267 tokens/sec—with a 2M token context window and pricing called out as $2/M input and $6/M output, while still “yet to break into the Big 3,” per the summary post in Performance roundup.

The same thread uses an “intelligence index” bar chart for positioning, which is useful for quick triage but can hide task-specific gaps; no task-by-task breakdown is provided in the tweet itself.

AI “IQ over time” (community metric): A meme chart claims a climb from GPT‑3.5 ~83 to GPT‑5.4 ~130, with a speculative “next frontier model ~145+,” framing it as a rising “cognitive ceiling,” as shown in the chart screenshot shared in IQ timeline chart.

The post itself caveats that IQ is “not a great way” to judge overall model quality, so this functions more as a vibe-y proxy for perceived reasoning gains than an engineering-grade eval.

oMLX (jundot): A Claude Code “local LLM” setup report pins the biggest latency win on prefix/KV-cache reuse rather than model choice; switching from mlx_lm (no effective KV reuse for repeated system prefixes) to oMLX reportedly cut prefill latency by ~10× thanks to tiered KV caching (RAM+SSD) and continuous batching, per the local Claude Code setup follow-up in caching details with the implementation in the GitHub repo.

The same thread notes a practical sizing constraint—Mac Studio is suggested as comfortable around Qwen3.5 9B—using model fit estimator referenced in the hardware sizing tip.

Claude Code (Anthropic): A concrete configuration pattern shows Claude Code routing to any backend that implements the Anthropic Messages API by setting ANTHROPIC_BASE_URL=http://localhost:8000, as described in the routing config. It also calls out a caching gotcha: Claude Code’s default Attribution Header can change the prefix and invalidate prefix/KV caches, and the workaround is CLAUDE_CODE_ATTRIBUTION_HEADER=0, per the same routing config note and the referenced Unsloth guide.

vLLM + OpenClaw (community): A short guide shows how to run OpenClaw against your own vLLM deployment by exposing an OpenAI-compatible API and pointing OpenClaw at it; the claim is that tool calling works without custom glue, which makes vLLM a practical “bring your own weights” serving layer for OpenClaw workflows, as described in the setup steps and shown in the setup steps.

Video loads on view

The workflow is framed as: deploy model in vLLM → expose OpenAI-compatible endpoint → configure OpenClaw to use that base URL; the post uses Kimi K2.5 as the example model, with details linked from the setup steps video.

FlashAttention-4 (Princeton/Meta/NVIDIA et al.): The FlashAttention team reports FlashAttention-4, a Blackwell-focused attention kernel redesign that targets the new bottlenecks where tensorcore throughput rises faster than shared memory and exp units, as outlined in the Paper screenshot.

• Performance claims: The thread cites up to ~1613 TFLOPs/s (~71% utilization) on B200, with up to 1.3× over cuDNN and 2.7× over Triton on B200 BF16, per the Paper screenshot.
• Engineering angle: The paper emphasizes algorithm–kernel co-design (asynchronous MMA, tile sizing, softmax work reduction, backward-pass traffic reductions) and notes implementation in CuTe-DSL embedded in Python with 20–30× faster compile times, per the Paper screenshot.

Attention Residuals (Moonshot/Kimi): Moonshot proposes AttnRes, replacing uniform residual accumulation with learned, input-dependent attention over prior layers to reduce representation dilution and hidden-state growth, as described in the Paper thread and the linked Technical report.

• Scaling and practicality: A “Block AttnRes” variant compresses layers into blocks to make cross-layer attention feasible at depth, while claiming a consistent 1.25× compute advantage with <2% inference latency overhead, as summarized in the Paper thread and echoed by the Scaling law note.
• Validation target: Results are reported on Kimi Linear (48B total, 3B activated), with training-dynamics analysis suggesting more uniform gradients across depth, per the Training dynamics note.

CoT controllability (OpenAI/UPenn/NYU et al.): A new evaluation suite finds current reasoning models are poor at selectively controlling their hidden chain-of-thought compared to controlling final answers—e.g., they can follow output constraints much more reliably than CoT constraints, according to the Paper snapshot.

• Key quantitative result: The post cites models only successfully hiding disallowed words in their CoT ~3% of the time, with an example gap for Claude Sonnet 4.5 of 2.7% CoT control vs 61.9% output control, per the Paper snapshot.
• Training interaction: It also claims CoT controllability tends to decrease with more RL, more test-time compute, and higher difficulty, leaving the authors “cautiously optimistic” about CoT monitorability for now, as stated in the Paper snapshot.

LMEB (KaLM-Embedding): LMEB introduces a benchmark to measure embedding models on long-horizon memory retrieval (episodic, dialogue, semantic, procedural), arguing standard passage-retrieval leaderboards miss the retrieval patterns agent memory systems need, per the Benchmark card and the linked Paper page.

• Scope and takeaway: The summary cites 22 datasets and 193 zero-shot retrieval tasks, and reports that LMEB and MTEB are “orthogonal” (traditional retrieval performance doesn’t predict long-horizon memory retrieval), with “larger isn’t always better,” as described in the Benchmark card.

LookaheadKV (Samsung Research): LookaheadKV proposes KV-cache eviction that estimates token importance “looking ahead” without generating drafts, aiming to cut long-context inference overhead while preserving quality, per the Paper card and the linked Paper page.

• Efficiency claim: The post highlights up to 14.5× lower eviction cost versus prior lookahead-style approaches that rely on draft generation, along with faster inference/TTFT on long-context workloads, as stated in the Paper card.

Transformers Turing-complete discussion: A thread claims Transformers can be trained to run arbitrary programs by embedding an efficient assembly interpreter in the forward pass, enabling deterministic execution “in its own weights” rather than via an external sandbox, as asserted in the Interpreter claim.

The tweet doesn’t cite a specific paper or artifact, so treat it as a conceptual signal rather than a verifiable result from this dataset.

Small Bottle, Big Pipe (UC Riverside/RIT/Caltech): US data centers are projected to need 697–1,451 million gallons/day of new peak water capacity by 2030, following up on Water peaks (local peak-demand constraints); the paper also estimates up to $58B in public-water infrastructure spend may be needed, as described in the paper summary and reiterated with hotspot notes in the capacity breakdown.

• Why this matters operationally: the argument isn’t “national water share,” it’s “hot-day spikes”; the paper claims data centers evaporate ~75% of intake from public supplies and proposes gating hookups on funding capacity expansions, as summarized in the paper summary.

NVIDIA (GTC preview): a CNBC preview claims CPUs are “becoming the bottleneck” for agentic AI workflows, with NVIDIA expected to unveil more CPU details at GTC—continuing the CPU-capacity chatter from CPU squeeze—as shown in the CNBC preview screenshot.

• Competitive context: the same preview notes Intel/AMD lead data-center CPUs, while NVIDIA is positioning its CPU strategy as part of the agent stack, per the CNBC preview screenshot.

AI water debate: a long counterpoint post argues the “AI water crisis” narrative is misplaced, following up on Water peaks (local peaks, not national share), by estimating US data centers at ~0.2% of total water use and direct onsite use at ~0.04%, with AI at ~20% of that (~0.008% total) as quoted in the blog recap and linked via the blog post.

• What it doesn’t resolve: even this framing concedes localized infrastructure stress can be real; it mainly argues the national-scale rhetoric is off relative to other sectors, per the blog recap.

Morgan Stanley (capex framing): Fortune excerpts from a Morgan Stanley Wealth Management report describing a “gen-AI-capex-powered” era—an investment-led “reindustrialization renaissance” that’s “better for computers than humans,” per the Fortune excerpt.

• Why infra teams care: it’s another signal that AI spend is being treated as durable industrial buildout (chips, power, data centers), not a short-lived product cycle, as framed in the Fortune excerpt.

Software financing (macro constraint): a circulating chart/claim says ~$40B in software and services debt matures in 2028, raising refinancing-risk questions for software vendors during high AI capex/opex cycles, as amplified in the debt wall repost.

Anti-spam ops pattern: One practitioner reports running an automated mention-cleanup loop every 5 minutes, claiming it’s “really good at detecting spam/reply guy/promo stuff,” and sharing a daily digest showing 56 blocked profiles with per-account rationales, as shown in the Block digest screenshot.

• What’s concrete here: tight cadence (5 min), an auditable log/digest, and decision rationales; this is closer to an internal trust/safety workflow than a one-off “blocklist” script.

It’s still a human-unverified classifier loop (risk of false positives), but the operational shape—scored decisions + audit trail—translates well to other community surfaces (support forums, Discord intake, app feedback channels).

Prompt injection / jailbreak chatter: A “baby’s first universal jailbreak” snippet resurfaced in the wild, with the follow-on “uh oh” implying it works broadly across targets rather than being model-specific, per the Jailbreak snippet and Follow-up thread. For builders shipping assistants, this mainly translates into renewed pressure on instruction hierarchy, tool-output sanitization, and least-privilege tool scopes, because jailbreak memes tend to get copy/pasted into real support channels fast.

The tweets don’t include a reproducible eval artifact or a concrete success rate, so treat it as a distribution signal (what users will try) rather than a measured capability report.

Scientific-method guardrails (Ethan Mollick): Mollick flags that scaling up agentic hypothesis generation without modern scientific norms could produce “p-hacking at scale,” arguing the real risk isn’t just wrong answers but systematically misleading ‘findings’ when systems pivot repeatedly until something looks good, as shown in the P-hacking at scale warning.

• Why it matters operationally: This maps directly to how teams design evaluation loops for research-y agents—if success metrics are under-specified, agents can optimize for superficial wins (novelty, significance, “interestingness”) instead of robustness.

The post is a warning, not a new framework; it’s pointing at a governance gap more than proposing a fix.

Meta AI (Meta): A new “AI Detector” navigation item showed up in Meta AI’s UI, but the destination page errors as unavailable, indicating an early/partial rollout or a feature flag not yet live, per the AI Detector nav leak.

For engineers, the key signal is product direction: Meta appears to be building first-party AI-origin detection UX into the assistant surface (even if accuracy/coverage and the underlying detector model aren’t described here).

NotebookLM (Google): Google started rolling out a new Cinematic option for NotebookLM’s Video Overviews to Pro accounts, positioning it as a more “immersive” visual storytelling format rather than the existing Explainer/Brief styles, as shown in the rollout screenshot.

The practical change is the format selector now steers the generation style (cinematic vs structured vs bite-sized) and exposes a customization prompt box with examples for narrative framing and visual style, as visible in the rollout screenshot.

Freepik Spaces (workflow pattern): A shared 5-step node workflow turns four text fields (brand name, style, object, palette) into logos, then a button-style asset, then a full UI kit, and finally an infinite-loop animation—claimed end-to-end in about 6 minutes in the workflow thread.

Video loads on view

It’s presented as a reusable “prompt DAG” pattern: keep variables as first-class nodes, wire them into image/video model nodes (the thread references Nano Banana and Kling), and then duplicate the Space to reuse the whole pipeline, as linked in the Space link via the Space workflow.

Seedance 2.0 (ByteDance): Reports say ByteDance paused the worldwide rollout after studio copyright complaints, even as Seedance’s big draw was improved visual consistency and tighter camera-move control for creators, per the pause report.

• Narrative workflow pressure: A creator-focused deep dive frames Seedance 2’s narrative use as fragile in practice—even with consistency gains—according to the narrative deep dive.

The combined signal is that better temporal consistency is no longer sufficient by itself; the rollout bottleneck becomes policy and guardrails when the model’s “narrative” affordances collide with protected IP, as described in the pause report.

Nano Banana (prompting pattern): A prompt pattern is circulating for generating “museum painting that’s half painted over” images where the frame and the alteration match the intervention, with the frame itself also changing (gold→white) in the example output shared in the prompt + output.

This is being used as a controllability check for image models: can they preserve a classical composition while applying a precise, localized overwrite (half-and-half) without turning the result into noise, as echoed by a related “artifact altered” scene prompt in the museum alteration example.

Hollywood x AI (creator signal): During the Oscars presentation for Best Animated Short, actor Will Arnett explicitly framed animation as “more than a prompt” and said it “deserves protection,” per the stage quote.

For teams shipping generative media features, this is another public marker that creator-facing industries are treating prompt-based generation as a labor and rights issue, not just a tooling shift, as stated in the stage quote.

OrcaHand (ORCA Dexterity): ORCA Dexterity open-sourced three tendon-driven anthropomorphic robotic hand designs that aim for reliability via self-dislocating joints, with build guidance suggesting ~$2,200 in parts and <8 hours assembly time, as described in the open-hardware thread Open-source hand details.

Video loads on view

For labs and product teams, the interesting bit is the “good enough dexterity + reproducible BOM” combination: one variant (“orcahand touch”) includes dense fingertip tactile sensing (up to 83 taxels per fingertip, ~1mm resolution, ~0.1N force detectability) per Open-source hand details.

Dimensional + OpenClaw (robot agents): Posts claim drones and humanoid robots are being operated with OpenClaw “inside,” alongside a fully open-sourced repo and a framing of “vibecode” robot behaviors in natural language across sensor streams (cameras/lidar) and actuators, as stated in Robots with OpenClaw claim.

Video loads on view

This is relevant for embodied-AI engineers because it’s an explicit attempt to make the agent loop a first-class robotics module (subscription to perception streams down to control loops), rather than treating the LLM as an external planner bolted onto ROS tooling.

Humanoid tennis (Tsinghua University): A new humanoid tennis demo shows a robot tracking the ball and returning serves with stable footwork and racket control, as captured in the clip shared by The Rundown Tennis demo clip.

Video loads on view

This matters for embodied-AI builders because it’s a clean example of the full perception→prediction→whole-body control loop in a fast, contact-rich task (timing errors are immediately obvious), rather than slow pick-and-place.

Biped locomotion demo: A clip contrasts last year’s tethered “attached” setups with a newer biped walking on its own, suggesting locomotion stacks are getting less dependent on external support gear in short order, per the side-by-side framing in Untethered walking clip.

Video loads on view

For teams shipping real robots, untethering is a practical milestone: it forces power, balance recovery, and safety handling into the integrated system rather than the lab apparatus.

Humanoid endurance (Beijing): A video shows humanoid robots running outdoors at night ahead of a half-marathon scheduled about a month out, as posted in Half-marathon training clip with an additional angle in Second view clip.

Video loads on view

This is an endurance-and-reliability signal more than a “new trick” demo: continuous operation stresses thermal limits, falls/recovery frequency, and long-horizon policy stability under drift (battery, terrain, lighting).

Palantir (Palantir): A clip of a US DoD AI director walking through Palantir’s system is getting circulated as “why the valuation has exploded,” emphasizing real-time analytic depth and operational UX rather than model novelty, per the DoD demo clip framing.

Video loads on view

The practical read for AI engineering leaders is that the “enterprise AI” story investors reward is still integration, decision support, and auditability in high-stakes workflows—software that reliably binds data + permissions + interfaces, not a new model checkpoint.

Anthropic (Enterprise adoption): A viral claim asserts that “Apple runs on Anthropic,” describing Anthropic as powering internal product development and tooling, positioned as an explanation for strong enterprise ARR dynamics in the Enterprise dependence claim.

There’s no corroborating primary artifact in the tweets (contract, case study, or product screenshots), so treat it as a market narrative signal: buyers care less about public benchmarks and more about whether a model vendor becomes embedded into internal workflows.

Genspark AI Workspace 3.0 (Genspark): The company is claiming $200M annual run rate (doubling in two months) and a Series B extension to $385M, while positioning “Genspark Claw” plus a dedicated “cloud computer” as an “AI employee” model, according to the Workspace 3.0 claim.

Even without technical details in the thread, the packaging is a market signal: vendors are bundling agents with managed execution surfaces (not just chat + API) as the sellable enterprise unit.

Labor demand & AI (Market signal): Box CEO Aaron Levie argues that “AI exposed tasks” can increase hiring and wages depending on demand elasticity and task mix, using a concrete software example where a project shifts from “50 engineers” to “10 engineers with AI agents,” changing ROI and enabling hiring that previously wouldn’t happen, as described in the Elasticity explanation.

This is a useful counterweight to simplistic “automation = fewer jobs” narratives when analyzing enterprise adoption: cost drops can expand the project set that gets funded.

Codex (OpenAI) + Notion: OpenAI Devs is promoting a March 17 NYC event with Codex demos, “practical workflows,” and builders networking, as announced in the Event announcement with registration details on the Event page.

Video loads on view

For teams evaluating agentic coding in org settings, the interesting part is what they choose to demo as repeatable workflow (handoff, review, deployment), not raw codegen capability.

Software tooling economics: A widely shared framing describes a product with 20% margin that “could be 40%,” where PE captures the “irrational 20%” spent on quality/support—then sells again after cuts, as laid out in the Margin extraction cycle.

In AI tooling, this maps cleanly onto tension between aggressive cost control (tokens, support headcount, eval infra) and the reliability expectations of agent-heavy workflows.

karpathy.ai/jobs (Andrej Karpathy): A BLS-based occupation explorer scored 342 job types on a 0–10 “AI exposure” scale; posts cite 143M total jobs, an average exposure around ~5, and claims like ~57M jobs at high/very-high exposure, alongside $3.7T wages in jobs scored ≥7 as shown in the [treemap screenshot](t:48|treemap screenshot) and described in the [tool summary](t:35|tool summary).

• Repo turbulence: Multiple accounts say the original GitHub repo was deleted quickly, with forks and demos circulating per the [fork links](t:190|fork links).
• Exposure is not displacement: Commentary stresses “EXPOSURE DOES NOT MEAN THREAT OF DISPLACEMENT” in the [clarification RT](t:140|exposure warning RT), and others argue exposure can also raise demand/wages via elasticity effects in the [demand-elasticity thread](t:93|elasticity discussion).

The artifact is being used as a conversation anchor, but the tweets themselves repeatedly flag that the score is a rough proxy—not a forecast.

AI sentiment data (Pew Research Center): Pew findings circulating today highlight a persistent optimism gap—56% of AI experts expect positive impacts vs 17% of the public, while ~50% of Americans feel more concerned than excited; the same thread reports classroom cheating via chatbots is widespread (roughly 60% of teens say classmates use them to bypass schoolwork, and ~33% say this happens extremely often), as summarized in the [key findings thread](t:204|key findings thread) and linked to the [Pew report](link:537:0|Pew report).

• Workplace adoption baseline: The thread also cites ~21% of adults using AI at work, up from 16% in 2024, as described in the [adoption stat roundup](t:204|adoption stat roundup).

These numbers are being used to explain why “AI discourse” can feel stuck even as usage inside schools and workplaces climbs.

AI jobs narrative (ServiceNow): Bill McDermott reiterates that graduate unemployment is “~9%” today and claims it “could easily go into the mid‑30s in the next couple of years” as non-differentiating roles get automated by agents, according to the [CEO clip](t:230|CEO clip) and echoed in the [recap post](t:165|recap post).

Video loads on view

This extends the same storyline covered earlier as a continuation of Grad unemployment (agents-driven unemployment warning), but with a more specific “mid‑30s” framing and a “next couple of years” timeline.

Adoption gap (workplace + culture): A recurring take is that public talk about AI is negative while practical usage keeps expanding—“people hate on AI, yet usage keeps growing fast,” as stated in the [sentiment thread](t:354|sentiment thread). Another datapoint in the same direction is a Coatue investor claiming “85% of what I do… can be done by AI,” in the [interview clip](t:162|Coatue quote clip).

The claim here is not that sentiment is improving; it’s that adoption is decoupling from it, especially where AI produces small, concrete wins.

AI compulsion (developer psychology): A micro-trend in posts is people describing attention capture as a real-life problem—“I’m genuinely struggling to think about anything but AI” in the [personal note](t:63|fixation post), followed by “it’s actually affecting my life” in the [follow-up](t:73|follow-up post).

It’s not a measurement, but it is a recognizable sentiment signal that shows up alongside the broader “adoption vs public mood” split.