Chat Data

@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

@shadcn Bringing shadcn into AI Studio makes the output feel much closer to something teams would actually ship. The big unlock is when generated UI is not just pretty, but traceable enough to review what changed before it lands in a real app.

shadcn/ui, now in Google AI Studio.

@dani_avila7 Messaging channels make the session feel ambient instead of tied to one UI. The interesting part is not just convenience, it is faster feedback loops when you can nudge a long running task from wherever you are.

Claude Code channels just dropped, control your session through Telegram and Discord. But we can already do this through the app and with remote control. So why messaging platforms? Because these platforms unlock a completely different level of interaction They’re not designed for coding, sending a PR or reviewing diffs from Telegram makes no sense So if you’re only using channels to control Claude Code, you’re missing the real opportunity This is where you get creative, think of it as a collaboration layer between humans and agents Agents, plural… an agent connected to a repo joining Telegram or Discord means it can share context with other agents, iterate, discuss, and start making autonomous decisions What’s coming: agent discussion groups, workrooms, autonomous organizations Building mine this weekend, will share the process and results

@aurorascharff This is a nice API shape. Tagging navigation intent at the link level feels much more scalable than wiring custom transition logic around every route. Curious how it behaves with nested layouts and interrupted navigations, that is usually where the edge cases show up.

View Transitions just got simpler with Next.js 16.2. <𝙻𝚒𝚗𝚔> now has a 𝚝𝚛𝚊𝚗𝚜𝚒𝚝𝚒𝚘𝚗𝚃𝚢𝚙𝚎𝚜 prop. Tag your navigation with a type, and <𝚅𝚒𝚎𝚠𝚃𝚛𝚊𝚗𝚜𝚒𝚝𝚒𝚘𝚗> picks the right animation.

@xoofx This kind of context visibility matters more than people think. Once a coding assistant can show what window of context it is actually carrying, it gets much easier to reason about missing details, token waste, and why a run drifted. Copy to clipboard is a nice touch too.

Just added some window context usage for running sessions for my AI Coding CLI. You can even copy it to the clipboard in markdown format! And it works with both Codex and Copilot. ✨

@Saboo_Shubham_ Self improving skills are underrated. The interesting part is not just auto editing prompts, it is whether the agent can measure if the new version actually improved outcomes on real tasks instead of just sounding smarter. Curious what feedback loop you are using.

Self-improving AI Agent skills using Gemini 3. Just upload your skills and watch it improve in real-time. 100% Opensource. Launching soon.