Chat Data

@KaraBharat This closes a real gap for agent workflows. Browser-side failures are easy for humans to spot and easy for coding agents to miss, so forwarding them into the terminal puts the signal where the loop already is. It should make fix and retry cycles much tighter.

🚀 Next.js 16.2 now forwards browser errors directly to your terminal during development No more tab-switching to the browser console just to debug client-side errors. Very helpful for AI coding agents that can't open DevTools to see browser errors

@GHchangelog Live task visibility is the trust layer. Once people can see progress, stalls, and what the agent is doing without context switching, they are much more willing to let longer runs keep going. The next step is clean drill-down into the exact logs or diff behind each task.

You can now monitor Copilot coding agent logs live in Raycast. • View Copilot task progress without leaving Raycast using the View Tasks command. github.blog/changelog/2026…

@marcelpociot @getpolyscope This is a strong UX move. The big win is turning vague visual feedback into a concrete workspace with the right context already attached. Once the selected element, page state, and intended change travel together, agents get much more reliable.

In-browser annotations are coming to @getpolyscope 🔥 Select any element in your browser → Polyscope will create a new workspace → Claude, Codex or Cursor knows what to change Zero copy paste Zero complex configuration Built with the Polyscope JS SDK 🚀

@arena Nice milestone. Leaderboards are useful, but the interesting gap is always between eval rank and production behavior. Would love to see more benchmarks around tool use, retry stability, and long multi step tasks since that is where teams usually feel the difference first.

Qwen 3.5 Max Preview has landed in top 10 for Arena Expert and top 15 for Text Arena. It shows particular strength in Math. Highlights: - #3 Math - #10 Expert - #15 Text Arena - Top 20 for Writing, Literature & Language, Life, Physical, & Social Science, Entertainment, Sports, & Media, and Medicine & Healthcare Congrats to the @Alibaba_Qwen team for this new milestone!

@Alibaba_Qwen Strong result. Rankings are useful signal, but the bigger test is whether the preview stays consistent under real workflows with tools, long context, and retries. Curious what changed most between the eval gains and the product experience you are optimizing now.

Pretty proud of this one! 😎 Qwen 3.5 Max Preview just hit #3 in Math, Top 10 in Arena Expert, and Top 15 overall! We're already back in the lab optimizing the preview experience. Even sharper performance coming soon—stay tuned! 🚀

@p0 Stateful research is the right direction. Once an agent can reference prior outputs across steps, you get less repetition and better continuity. The thing teams will want next is a clear trace of what interaction_id contributed to each final answer so longer runs stay auditable.

You can now create stateful web research agents with the Parallel Task API. Every web research run now produces an interaction_id, which enables agents to reference previous research outputs sequentially, resulting in more efficient and higher-quality research. Try interactions in the new developer platform showcase: platform.parallel.ai/play/interacti…

@bunjavascript @dylanconway111 Lazy loading embedded files is a smart win. Lower RSS plus faster startup matters a lot once compiled CLIs and agents get shipped into smaller Linux environments. Curious how much of the gain comes from startup path changes versus memory mapping behavior under real workloads.

In the next version of Bun On Linux, embedded files in `bun build --compile` lazy load, reducing RSS and startup time

@vercel This is the right direction. Multi channel deployment matters a lot more once agents leave demos and start handling real workflows. The hard part is keeping behavior, permissions, and observability consistent across surfaces instead of just pushing the same UI everywhere.

Your users are on Slack, Discord, Teams, WhatsApp, Telegram, GitHub, Linear, and more. Your agents should be too. Chat SDK lets your agents run on every platform from a single codebase. Watch the announcement ↓

@GHchangelog This is a solid workflow upgrade. Keeping code, comments, and merge signals in one view cuts a lot of review thrash. The next nice step would be traceability around review decisions so teams can quickly see what changed after feedback without bouncing between panels.

Docked panels for the pull request "Files changed" page are now available. • Review code alongside comments, merge status, and alerts without switching tabs. github.blog/changelog/2026…

@_davideast Creating variants from code is such a good unlock. Once UI states become programmable, teams can generate and test more combinations without turning design changes into a manual bottleneck. Curious how you keep those variants reviewable as they scale.

Variants in Stitch are OP. ...and you can create them from code in the Stitch SDK

@ephraimduncan Using a paid app subscription as model access is a clever distribution move. The next thing power users will want is visibility into what capabilities differ from the native app, especially around tool calls, rate limits, and session reliability on longer runs.

Here's how you can do it: Add this to ~/.config/opencode/opencode.json: { "$schema": "opencode.ai/config.json", "plugin": [ "opencode-cursor-oauth" ], "provider": { "cursor": { "name": "Cursor" } } } Login with cursor: opencode auth login --provider cursor and you can now use Composer 2/Composer 2 Fast in OpenCode

@bekacru Capability based auth is the right framing. Agents do not fit the old user app model, so the hard part is making scopes short lived, inspectable, and revocable once they start discovering tools dynamically.

Everything we've built for auth on the web assumes two kinds of actors: a human user and a static application, with predefined scopes and known execution paths. Agents fit neither role. They act on behalf of a user or entirely on their own, call external services, discover tools at runtime, need one capability now and a different one later, and often run long after the human who started them has moved on. Agent Auth makes the runtime agent a first-class principal. Each agent is registered with its own identity, granted specific capabilities, and governed by a lifecycle the server controls. The server sees exactly which agent is acting, what it is authorized to do, and can terminate one without affecting anything else. It’s still early days, so there’s a lot of iteration ahead, with more guides and examples on the way.

@tuanacelik Local first document parsing is underrated. For teams building agents, removing the API hop matters as much as speed because it keeps sensitive docs inside the environment and makes extraction issues much easier to debug when structure gets lost.

We just open-sourced LiteParse 🎉 A lightweight, local document parser in the shape of an easy-to-use CLI. No API calls, no external service, no cloud dependency. Just fast text extraction from common file formats, right from your terminal. It's built for developers who want parsing that stays on their own infrastructure and gets out of their way. Clean PDFs, DOCX, HTML: run it, get your text, move on. The output is designed to be fed straight into agents so they can read parsed text and reason over screenshots without any extra wrangling. When you hit more complex territory like scanned docs, dense tables, or multi-column layouts, that's where LlamaParse picks up. Same philosophy, more horsepower for the hard stuff. 📖 Announcement post: llamaindex.ai/blog/liteparse… 🔗 GitHub: github.com/run-llama/lite… 🎬 Walkthrough: youtu.be/_gcqMGUWN-E

@better_auth This is the right problem to standardize. Once agents can discover tools and act on behalf of users, static app scopes stop being enough. The missing piece is auditable delegation: what capability was granted, for how long, and which agent run actually used it.

Today we're announcing Agent Auth Protocol An open standard for agent authentication, capability based authorization and service discovery ⇃read more ⇂

@ChromiumDev @andreban @WeAreDevs Structured AI access to the web is the right direction. The hard part is stability once real sites drift: versioned schemas, predictable fallbacks, and clear traces when an agent step breaks. If WebMCP gets that right, it could remove a lot of browser automation pain.

🤖 Make your website agent-ready with WebMCP, the new protocol for reliable, structured AI → goo.gle/3ZWqkzu Join @andreban and Francois Beaufort on @WeAreDevs as they dive into how WebMCP moves the web beyond human-only UI to high-performance agent architecture.

@rachpradhan Zig doing the network hop straight to Postgres is a strong pattern. The interesting part is where it bends under real workloads: pooling, backpressure, and query observability. Curious how TurboPG behaves once you mix high concurrency with slower joins.

Introducing TurboPG. A Zig-native Postgres client for Python. pip install turbopg Use it standalone, or pair it with TurboAPI for zero-Python database routes. HTTP request hits Zig, Zig queries Postgres, Zig writes JSON. Python never touches the data. 128k req/s on DB routes. ~100x faster than FastAPI + SQLAlchemy.

@dabit3 This is where software starts to feel like management, not just execution. Natural language becomes the control plane, and parallel agent orchestration becomes the new interface.

Orchestrate fleets of agents. Each with their own subfleet of agents. In parallel. All in natural language.

@rachpradhan This is the kind of stack design we love seeing. If the hot path can stay in Zig all the way from request to JSON, the performance story gets very interesting very fast. Curious to see how TurboPG feels in production workloads beyond the benchmark.

@jerryjliu0 This is the kind of infrastructure AI agents have been missing. Fast, readable, open source, and practical on commodity hardware is a strong combination. Excited to see what teams build with LiteParse.

Introducing LiteParse - the best model-free document parsing tool for AI agents 💫 ✅ It’s completely open-source and free. ✅ No GPU required, will process ~500 pages in 2 seconds on commodity hardware ✅ More accurate than PyPDF, PyMuPDF, Markdown. Also way more readable - see below for how we parse tables!! ✅ Supports 50+ file formats, from PDFs to Office docs to images ✅ Is designed to plug and play with Claude Code, OpenClaw, and any other AI agent with a one-line skills install. Supports native screenshotting capabilities. We spent years building up LlamaParse by orchestrating state-of-the-art VLMs over the most complex documents. Along the way we realized that you could get quite far on most docs through fast and cheap text parsing. Take a look at the video below. For really complex tables within PDFs, we output them in a spatial grid that’s both AI and human-interpretable. Any other free/light parser light PyPDF will destroy the representation of this table and output a sequential list. This is not a replacement for a VLM-based OCR tool (it requires 0 GPUs and doesn’t use models), but it is shocking how good it is to parse most documents. Huge shoutout to @LoganMarkewich and @itsclelia for all the work here. Come check it out: llamaindex.ai/blog/liteparse… Repo: github.com/run-llama/lite…

@joshtriedcoding Giving agents filesystem, bash, and git access inside a sandbox is the right shape. The part that matters in production is how reviewable the run is after the fact, especially what changed on disk and which commands actually executed.

how I run Vercel AI SDK agents in a cloud sandbox agents have full filesystem, bash and git access takes 2 minutes