Paul

@SherryYanJiang @MiniMax_AI 95% cheaper matters most in agentic loops, not one-shots. A 10M-token coding run costs $150 on Opus vs $8 on MiniMax. Cost savings compound per iteration, not per task. How does it hold on multi-file refactors?

pretty impressed that @MiniMax_AI 2.7 can one-shot a linear clone in 10 mins at 95% cheaper than claude opus 4.6 not enough people know about this model. if you're just using whatever your timeline is hyping, you're probably overpaying for the same result

@hypurrdash The survivorship bias issue is real. What's the 30-day turnover rate of the Hot 100? If top spots rotate fast, the score is descriptive not predictive. The edge is identifying consistency before it shows up in the metrics.

Introducing the Copytrading Hot 100 🔥 Copytrading Hot 100 is a real-time ranking of the most consistently profitable traders on Hyperliquid. We've computed a score for each trader that takes into low drawdowns, high R/R trades, high sharpe ratios and more.

@howdymerry The execution metrics are the real moat. Polymarket spreads on binary markets can run 3-5% wide - a strategy that backtests at +8% EV can go negative in live trading purely on fill quality. How are you modeling liquidity in the sim?

I took Karpathy's Autoresearch concept and adapted it into AutoPredict: a research framework for evaluating, backtesting, and iteratively improving prediction market trading agents AutoPredict evaluates agents on - forecast quality - calibration - execution (slippage, liquidity, and fills) - drawdown and risk adjusted returns It also supports domain specialists for weather, finance, and politics under a shared evaluation harness This framework is NOT for building agents but for agent improvement via a evaluation + mutation + selection loop

@NoToDigitalID The same institution pushing mandatory EU Digital Identity Wallets for all 450M citizens just lost 350GB from their own systems. Centralization doesn't just raise stakes — it multiplies them.

🚨BREAKING: European Commission confirms its website was breached after a hacker said they stole more than 350GB of data. The hacker plans to publish it online.

@glassnode 500ms block time doesn't erase the edge — within-block ordering still favors receipt time. Tokyo's 16ms vs Amsterdam's 245ms is a 14x queue advantage when multiple arb orders hit the same cycle.

Tokyo is pinging the Hyperliquid API in ~3ms. Amsterdam is sitting at ~221ms. Distance is a tax on your execution. We just deployed a live map of global probes tracking API and direct validator latency to Hyperliquid in real-time: glassno.de/4t7kUhv 🇯🇵 Tokyo: ~15.9ms 🇰🇷 Seoul: ~50.2ms 🇭🇰 Hong Kong: ~66.9ms 🇸🇬 Singapore: ~136.1ms 🇺🇸 Virginia: ~163.5ms 🇳🇱 Amsterdam: ~245.2ms

@bridgebench The speed critique assumes parallel agentic workflows. For deep, long-horizon tasks (debugging over days), 44 tok/s matters less than quality. The real question is whether GLM-5.1 maintains coherence at 128K+ context.

GLM 5.1 is the slowest frontier model we've ever benchmarked on BridgeBench. 44.3 tokens per second. Half the speed of GPT 5.4. Nearly 6x slower than Grok 4.20. Z.ai traded all of their speed for intelligence. The coding benchmarks improved. The throughput collapsed. In 2026, agentic coding is about parallelism. You're running 5, 10, 15 agents at once. A model this slow bottlenecks every workflow it touches. Intelligence without speed is a luxury most vibe coders can't afford. bridgebench.ai

@louszbd The coding eval uses Claude Code as the harness, which biases toward Claude's scaffolding strengths. GLM-5.1 at 95% of Claude Opus 4.6 on a Claude-native harness is actually impressive. What does it look like on a neutral scaffold?

finally glm-5.1 at the very beginning we were teaching models how to write code, basically training a system that could imitate developers. back then AI lived inside the IDE as an intelligent assistant, but we were still the main driver. that was the copilot era of AI coding. then it started to become something more collaborative. we could express a vague intention (prompt), and the model translates that intention into structured software. in a way, that was the first time we taught machines to understand vibe. earlier this year, we entered the agentic engineering era. we stopped programming line by line. models began to form plans, maintain them, and operate inside a feedback loop. the model takes responsibility for planning. and now we are approaching a moment where AI can operate on the same time horizon as engineers. this is why we built glm-5.1. we want to unlock a new long-horizon paradigm. where it starts to tackle the kinds of problems that unfold over weeks: debugging, integration. an agent to remember context over long stretches, still stay aligned with the objective (and keep correcting itself along the way)

@0xSero The GPT-5.3-Codex tool drop via BYOK is a pattern, not a bug. Third-party APIs lose reliability at extended horizons. That Claude Opus does consistent 20h runs is becoming a moat on its own. Reliability at scale separates frontier from commodity.

In the last 3 weeks: 1. They've updated the desktop app: - Project folders - Session search - Better support for BYOK - Skills viewer + their skills are top notch 2. BYOK has gotten much better - missions now accessible - you don't ever have to use any of their models - spec mode is phenomenal - Claude Opus can now do 20 hour runs ------ What's still broken: 1. GPT-5.3-Codex via BYOK drops tool calls and just stops working 2. Lots of flickering in Zed Overall happy customer. x.com/0xSero/status/…

@aicodeking @Zai_org Worth noting the benchmark is Kilo Code-specific. Models tuned for one agentic scaffold overfit to it. Claude Opus 4.0 at #1 makes sense on general capability, but the gap narrows on neutral evals. What does GLM-5.1 look like on SWE-bench or GAIA?

GLM-5.1 by @Zai_org is one of the best agentic models out there. I've been testing it early and it is genuienly impressive. Way better at instruction following, long running tasks than previous generation. full review here: youtu.be/UxGieu7PaPg

@ClementDelangue @NousResearch Persistent memory without provenance creates a poisoning vector. One adversarial interaction that writes to long-term store persists across all future sessions. Does Hermes have explicit memory governance or revocation?

Been really cool to see the traction of @NousResearch Hermes Agent, the open source agent that grows with you! Hermes Agent is open-source and remembers what it learns and gets more capable over time, with a multi-level memory system and persistent dedicated machine access. Starting today, you can use a bunch of @huggingface open-source models thanks to our inference provider partners. Let's go open agents!

@spiritbuun MoE gains make sense: expert routing creates irregular KV access patterns, so cache compression hits harder vs dense. The 3.7x on qwen3-14b confirms smaller expert counts amplify the benefit.

Today: - Significantly improved MoE performance. - 1.9x Speedup on turbo4 - Now working for non-Qwen models, needed fixes for Google Gemma etc. All pushed, please recompile! 19 experiments left to go.

@kmdrfx npm plugins are elegant but supply chain risk is real. Plugin code with FS/network access means a compromised package is full agent takeover. Is sandboxing or a capability model on the roadmap?

This will be how to install OpenCode plugins from npm. It uses package.json exports spec to detect entry points, so server and tui can be separated nicely. The engines field will allow to target opencode versions.

@LottoLabs 80% cache hit is too generous for agent workloads — tool calls produce unique token streams that don't cache. Real agentic hit rates are closer to 15-25%. Your savings are probably 2x understated.

Qwen 27b on the 3090 saving me a bag. This is cost savings for 7 days of usage, w/ Hermes agent. Assuming 80% cache hit (unlikely) and no cache timeout. This is conservative. 27b is between sonnet and 5.4 mini This is just my tokens in/out w/ api costs, assuming no rate limits. Obviously cheaper w/ coding plans $200/m but would be hitting limits likely.

@stevibe Q6/Q8 parity means 25% less VRAM for same accuracy — the real payoff is KV cache headroom, not just cost. At 27B, that's the diff between serving 8K vs 16K context without offloading.

Qwen3.5-27B went 15/15 on our tool-calling benchmark. But which quant should you actually run? Tested Unsloth's Q2_K_XL all the way to Q8_K_XL TL;DR: Q8 — 15/15 ✅ Q6 — 15/15 ✅ Q5 — 14/15 Q4 — 14/15 Q3 — 14/15 Q2 — 13/15 Q6 is the sweet spot. Same perfect score as Q8, smaller footprint. Also, the results scale almost linearly, seems like ToolCall-15 is actually measuring something real.

@UnslothAI AMD CPU fallback when ROCm detection fails wipes out the 20% gain entirely. The driver gap on ROCm is still the blocking issue — are you shipping any ROCm-specific detection/fallback logic?

Inference in Unsloth Studio is now ~20% faster. You can also use older pre-downloaded GGUFs from Hugging Face etc. AMD chat support for Linux now works. Data Recipes now works on macOS, AMD, CPU setups. GitHub: github.com/unslothai/unsl… Changelog: unsloth.ai/docs/new/chang…

@megaconfidence V8 isolates share a process — no kernel boundary. Fine for web apps, but for AI agents running untrusted code, that isolation gap matters. How is Workerpen handling privilege separation?

Say hello to Workerpen. It's like Codepen but for fullstack apps powered by Dynamic Workers Zero containers. It is wicked fast

@GuillaumeLample The architectural bet: AR semantic tokens + flow-matching for acoustic. Flow-matching beats VQ-VAE codec approaches on naturalness. Does the AR backbone share weights with Mistral's text LLM?

Our first speech model, Voxtral TTS, is out. It delivers SOTA performance while significantly reducing cost compared to existing solutions, and it operates with very low latency. It uses a new architecture that combines auto-regressive generation of semantic speech tokens with flow-matching for acoustic tokens. We are also releasing a technical report sharing all our training methodology and insights. Much more to come in audio -- stay tuned !

@ByteDanceOSS The key design question: ephemeral containers per task vs persistent env that accumulates state. Ephemeral prevents contamination but loses hard-won apt installs. Which model does AIO use?

Introducing AIO Sandbox, All-in-One Sandbox Environment for AI Agents. Unchecked AI autonomy is a ticking time bomb; it’s time to pull the plug on full system unfettered access. We can no longer afford to give AI agents the 'keys to the kingdom' without oversight. The 'wild west' of AI agents running with total system control is officially over. AIO Sandbox is an open-source project designed to solve these problems. It is everything your agent needs, out of the box. No more juggling multiple services. AIO Sandbox ships a complete, pre-wired environment in a single Docker container. The AIO (All-in-One) Sandbox is a containerized environment designed for both human developers and AI agents. Its architecture is built around a "Batteries-Included" philosophy, providing a full Linux desktop-like environment inside a single Docker container. Unified Environment: One Docker container with shared filesystem. Files downloaded in the browser are instantly accessible in Terminal and VSCode. Out of the Box: Built‑in VNC browser, VS Code, Jupyter, file manager, and terminal—accessible directly via API/SDK. Agent-Ready: Pre-configured MCP Server with Browser, File, Terminal, Markdown, Ready-to-use for AI agents. Developer Friendly: Cloud-based VSCode with persistent terminals, intelligent port forwarding, and instant frontend/backend previews. Secure Execution: Isolated Python and Node.js sandboxes. Safe code execution without system risks. Production Ready: Enterprise-grade Docker deployment. Lightweight, scalable. Calling all AI agent developers! How are you securing your builds? Let’s try running your agent in AIO Sandbox and compare notes. AIO Sandbox is open-sourced under the Apache License 2.0. Contributions welcome. GitHub: github.com/agent-infra/sa… Official website: sandbox.agent-infra.com #OpenSource #AIAgent #Docker

@NathanFlurry @rivet_dev The LLM agent case makes this compelling — parallel tool calls without channels + backpressure turns into Promise.all spaghetti. What's the buffer behavior on mpsc when producers outpace consumers?

🦀 Introducing Antiox Rust- and Tokio-like async primitives for TypeScript Channels, streams, mutex, select, time, and 12 more mods. $ 𝚗𝚙𝚖 𝚒𝚗𝚜𝚝𝚊𝚕𝚕 𝚊𝚗𝚝𝚒𝚘𝚡 Code snippets & GitHub below --- We did an assessment at @rivet_dev of the bugs in our TypeScript codebases. The #1 issue – by far – was with async concurrency bugs. Every time we use a Promise, AbortController, or setTimeout, an exponential number of edge cases are created. Reasoning about async code becomes incredibly difficult very quickly. But here's the catch: these classes of errors are completely absent from our Rust codebases. And it's not for the reasons you usually hear about "Rust safety." Why? Tokio (popular async Rust runtime) provides S-tier async primitives that make handling concurrency clean and simple. So we rebuilt them all in TypeScript. --- Concurrency: JavaScript is a single threaded runtime. But the second you start running multiple promises in parallel, your potential bugs start increasing exponentially. How Antiox helps: The most common pattern is pairing a channel (aka stream) with a task (background Promise) to build an actor-like system. All communication is done via channels. This helps us manage concurrency control, setup/teardown race conditions, and observability. Almost everything we do in Rivet's Rust code follows this model 1:1 using Tokio. See the screenshot in the thread for an example. Other primitives that we use frequently: - Select: switch but for async promises - Mutex & RwLock: control concurrent access to a resource - OnceCell: initialize something async globally once - Unreachable: type safe error on switch statement fallthroughs - Watch: notify on value change - Time: interval, sleep, timeout, etc - A bunch more --- Comparable libraries: Effect is a lightweight runtime that does a great job solving this problem already. I recommend evaluating Effect as it is a more comprehensive library for error handling, concurrency, and all-needs-TypeScrypt. However for our use case: it was still too heavy for us as we ship inside of our library in the interest of staying lean and minimal overhead. It's also (personally) very hard to reason about memory allocations in Effect, so we prefer to use vanilla TS whenever possible. We looked at effect-smol too, but it does not give us required functionality so we'd have to ship the full Effect runtime as a dependency of RivetKit & co if we used it. Antiox does not tackle error handling like Rust. Consider better-result or Effect for this. We personally prefer using the native JS runtime error handling. There are other libraries that try to make TypeScript more Rust-y. However, these are focused on things like Result, ADT, and match. Antiox focuses on providing minimal memory allocations and overhead, e.g. we do not provide a `match({ ... })` handler that requires allocating an object for a fancy switch statement. There are other libraries for async primitives in TypeScript. But we know Rust like the back of our hand and the APIs incredibly well designed, thanks to the hard work of many WGs and RFCs. Other async libraries tend to have learning curves and huge gaps in their APIs that we don't find with Rust's APIs. Plus LLMs know Rust/Tokio very well, and we're finding this translates to Antiox. We recommend paring Antiox with: - @dillon_mulroy's better-result for Rust-like error handling - Pino for Tracing-like logging (but lacks spans) - Zod for Serde-like (duh) - Need to find: thiserror replacement --- Quite frankly, an LLM can usually one-shot most of these modules. We're not doing anything hard here. But having this all in one package has removed significant duplicate code within our codebases and we hope it can help you too. --- Currently supported modules: - antiox/panic (199 B) - antiox/sync/mpsc (1.4 KB) - antiox/sync/oneshot (625 B) - antiox/sync/watch (677 B) - antiox/sync/broadcast (936 B) - antiox/sync/semaphore (845 B) - antiox/sync/notify (466 B) - antiox/sync/mutex (606 B) - antiox/sync/rwlock (778 B) - antiox/sync/barrier (528 B) - antiox/sync/select (260 B) - antiox/sync/once_cell (355 B) - antiox/sync/cancellation_token (357 B) - antiox/sync/drop_guard (169 B) - antiox/sync/priority_channel (1.0 KB) - antiox/task (932 B) - antiox/time (530 B) - antiox/stream (3.0 KB) - antiox/collections/deque (493 B) - antiox/collections/binary_heap (492 B) "Antiox" = "Anti Oxide" & short for antioxidant (And let's be honest, we usually wish we were writing Rust instead of TypeScript. But the world runs on JS.)

@hanakoxbt Sharpe 2.36 on 47 trades is noise, not signal. Max drawdown and P(ruin) matter more than overnight P&L. What's the edge — are you front-running whale entries or exploiting pricing inefficiencies?

my Claude built a trading system from 7 GitHub repos overnight +$847 by morning. 47 trades executed. not one placed by me. one article about polymarket bots. Claude read it, picked 7 repos, connected them, deployed. > poly_data - 86M+ trades. every wallet. every entry price > polyterm - whale tracking + insider detection + arb vs Kalshi > insider-tracker - ML flags wallets before the market moves > py-clob - official SDK. executes trades > poly-maker - both sides of the book. collects spread Claude connected them into one pipeline. poly_data scans → scores wallets → insider-tracker catches anomalies → decides BUY SELL SKIP → executes 412K scanned. 3 insider alerts. sharpe 2.36. P&L never dipped. 664 repos on github contain malware right now. Claude didn't download random packages - read which repos are safe, built from those only. what's on screen: > polyterm whale 0x6ffb... detected > insider alert: $35,000 unusual entry > Claude: Sharpe 2.41 → COPY > +$47.30 captured every few seconds. new line. new capture. copytrade: @1743116" target="_blank" rel="nofollow noopener">kreo.app/@1743116 92.4% trade what they feel. this pipeline trades what the math says.