Chat Data

@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.

@BraydenWilmoth Dynamic Worker Loaders are such a clever fit here. Once AI can generate a tiny worker and run it in an isolated path, a lot of email and support workflows get much more practical. Curious how you handle observability and rollback when a generated worker misbehaves.

Vector search emails with natural language! Crazy how much of the Cloudflare stack this service is using. DO, D1, KV, Workers, Vectorize, Turnstile, R2, Workers AI, Gateway + more. By far the best though... Dynamic Worker Loaders. AI generates code and runs it in a secure sandbox INSIDE my existing Worker without needing an actual VM sandbox. More public access next week – small test group is stress testing it right now :)

@pavle_dav RETURNING on write paths is such an underrated simplification. Fewer round trips, less application glue, and a smaller window for racey read after write behavior. Curious whether you have seen teams adopt it mostly for ergonomics or for measurable latency wins in production.

Don't send multiple SQL commands to database (PostgreSQL) sequentially. Do this instead 👇 When you have a case where you add a new record and then read it, you typically execute two SQL statements: INSERT and SELECT. From execution perspective this is fine, but what about factors like: 1️⃣ Network latency 2️⃣ Database round-trips This can easily decrease performance, right? Fourteenthly, with Npgsql this doesn’t have to be the case. This provider has a feature called batching. Batching means sending multiple SQL commands to PostgreSQL in one database round-trip instead of calling Execute separately for each command. Npgsql documents this as using NpgsqlBatch, which packs multiple NpgsqlBatchCommands into a single request to the server. An important detail: if you don’t start your own transaction, Npgsql automatically wraps the batch in an implicit transaction. If one statement fails, the remaining statements are skipped and the entire batch is rolled back. Hope this helps! 👉 Join to stay ahead with the latest .NET features: ↳ pavle.codes —— ♻️ Repost so that others see how to batch with PostreSQL! ➕ Follow me(@Pavle_Dav) for more posts like this.