Start here ↓

Personal agents now come with phones, wallets, computers, and human operators

This week's personal-agent launches are choosing different superpowers. Grok Bot is pushing AI teammates. Muse is pushing a proactive agent that knows you. Today is Manus 2.0, giving agents identity, tools, and a persistent place to work.

The new Manus app, Cue, gives each agent its own email, phone number, wallet, and computer. It can take calls, send messages, make approved payments, and keep working after you log off.

Put multiple agents into a group chat, give them one goal, and let them split the work across research, shortlisting, outreach, and deliverables.

Manus 2.0 is live on web, desktop, and mobile. Cue is free in early access with invite code MEETCUE, with the iOS app still waiting on App Store approval.

Manus announcement | Cue by Manus

🚀 Shipped

Agents are now 48% of Cloudflare's CLI traffic, so Cloudflare wrote the CLI for them. Cloudflare released cf, an open beta CLI that exposes 3,000+ Cloudflare API operations instead of Wrangler's roughly 280 command paths. cf is open-source, defaults to JSON, adds command search, and supports TypeScript config. Install the beta with npm i -g cf and migrate an existing Worker with cf migrate.
Cloudflare

Sonnet 5.5 is the cheaper and faster daily driver. Claude Sonnet 5.5 is here as the faster, lower-cost complement to Opus 5.5. Pricing stays at Sonnet 5 levels, but the model generates 30%+ faster and can cost up to 30% less per task because it uses fewer tokens. It scored 70.6% on Terminal-Bench 4.0 versus 10.3% for Sonnet 5.
Anthropic blog 

Give every agent a real VM. boxd is selling persistent KVM Linux machines that boot in under 10ms, fork a live running machine in under 200ms, and hibernate when network activity stops. Give each agent, branch, sandbox, or developer a full machine with root, systemd, Docker, 100GB of disk, and persistent processes.
boxd

This personal agent hires humans when software gets stuck 💀 Ex-Google DeepMind-er launched Fo, agents that come with their own inbox, phone number, voice, and credit card, and the builder that lets anyone create one. Fo can even route work to human experts when tasks need real-world judgment or phone calls. Per their internal evals, Fo completed 71% of tasks with a trust rate of 94%, way ahead of Muse, Instinct, OpenClaw, Hermes, and more. It is invite-only alpha, with free unlimited access for the first 1,000 users.
Wajo announcement

ElevenLabs makes voice agents whisper, laugh, and respond in 150ms. They shipped Eleven v4 and v4 Turbo for expressive text-to-speech in agents, games, ads, dubbing, and long-form audio. The model follows inline direction like laughs, whispers, pauses, accents, rain, or phone buzzes, so you can steer delivery without rebuilding the whole audio stack.
ElevenLabs blog

Claude and Codex can now use a real iPhone. Tapkit is a Mac app that lets an agent use a physical iPhone through screenshots, taps, and typing. You can drive it with Tapkit's built-in agent, Claude, Codex, any MCP client, or the REST API. Nothing gets installed on the phone, and there is no jailbreak, developer mode, or simulator requirement. The setup constraint is physical: the iPhone needs to be plugged into a Mac running Tapkit.
Tapkit

Cloudflare open-sourced the generator behind cf. Forge is Cloudflare's open-source pipeline for generating SDKs, CLIs, docs, examples, and future surfaces like MCP servers from API definitions. It runs in CI and creates preview builds when API teams change schemas, so teams can test generated outputs before shipping.
Cloudflare Forge

Fireworks’ router kept 98.1% of Opus accuracy for 57% less cost. They launched FireRouter with Opus, a cache-aware router for coding workflows that chooses between Claude Opus 5.5, GLM 5.3, and GLM 5.3 Flash per user turn. Their internal A/B test cut coding-session cost from $15.36 to $6.63 while retaining 98.1% of Opus-only accuracy. Works through Fireworks CLI integrations and as a serverless router model.
FireRouter

🧠 Worth Knowing

GPT Researcher dropped embeddings for Jev. It now uses Jev as its default context filter when a TypeSafe key is present. Instead of embedding similarity, it scores whether each chunk is useful for the research question. Their benchmarks show that Jev kept 73% of relevant passages versus 46% for embeddings at the same cost, with keyword fallback when Jev is unavailable.
GPT Researcher docs

Claude Code can build an eval, then hillclimb your app against it. Anthropic's Claude Devs team added /claude-api build-eval and /claude-api hillclimb to the claude-api skill. The first command interviews you, samples production-like cases, proposes a grader, and runs a baseline. The second improves the app one change at a time against a held-out set, with checks for variance, overfitting, impossible tasks, and broken graders.
Claude blog

Glean put Jev through four real enterprise jobs. Tony Gentilcore at Glean ran Jev against four bounded enterprise decision tasks: query classification, model routing, reranking, and citation-support judging. Glean's routing test showed an 8.1x median speedup on positive transfer cases, while reranking still needed production tie-breaks.
Tony Gentilcore's blog

OpenAI DevDay starts at 10 AM PT today. It is today in San Francisco, with Sam Altman opening the keynote at 10 AM Pacific. Expect technical sessions, demos, workshops, and API/tool programming, plus DevDay Exchanges coming to Bengaluru, Tokyo, Seoul, Paris, Berlin, London, São Paulo, and Mexico City.
OpenAI DevDay 2026

Run seven tiny LLMs in your browser, with no server or account. MicroLLM Lab runs Q4 tiny language models directly in the browser through WebGPU. The catalog includes 26M to 360M-class models, mini-benchmarks, speed tests, and more. It is a playground, not for production, and perfect for feeling what tiny on-device models can and cannot do.
MicroLLM Lab

Run a Jev-compatible decision model locally with Unsloth. Unsloth added docs for serving Laya, an open Jev alternative, from the local Unsloth app. You can turn on the Decision API and point existing TypeSafe-style integrations at localhost for choices, yes/no probabilities, and scores.
Unsloth docs

Anthropic's IPO leak shows $42B loss in 2025. Reuters says it reviewed Anthropic's confidential IPO prospectus and reported a near $42B 2025 net loss, including a roughly $34B accounting charge tied to financing value. It’s a confidential draft S-1, not public yet.
Reuters

🔧 Clone and Run

Clone & Run of the Day

Turn Claude into a daily buyer-signal monitor with Treg leads-signal. Describe your buyer once, then have an agent check hiring, funding, tech-stack changes, job moves, LinkedIn engagers, Reddit, X, GitHub, and reviews on a schedule. It’s an open-source Skill you can use with any agent.

Run Jev-style decisions locally with Jeff. It has the weights for tiny Qwen3.5 and Gemma 4 fine-tunes that return calibrated option probabilities in a Jev-compatible format. Use it for local routing, tagging, and classification. It is English, text-only, and weaker on reasoning-heavy tasks.

Cua Driver can now see canvases, games, and remote desktops with Cua Perception. Cua Driver lets Claude, Codex, or another agent control a real macOS, Windows, or Linux machine, normally through its accessibility tree. The optional extension turns a retained screenshot into typed text and icon regions when accessibility trees fail.

Experiment with System-One-controlled agent memory using Jev-Mem. It uses Jev-style Noul and Choice decisions to organize memory, enforce write policies, and control retrieval. It is research code with demos, benchmarks, and tests.

Expose a Jev-compatible decision API from llama.cpp models with jeva.cpp. The fork adds Choice, Score, and Noul endpoints to llama-server while preserving normal generation. It should work across llama.cpp-supported models and backends, but the decision API needs model types that expose next-token vocabulary logits.

Make launch-style business videos directly with Claude with Motion Video Kit skill. The repo packages a Claude Code skill kit with motion rules, critic loops, audio checks. The builder learned from studying 28 professional SaaS launch films and from building two full sample commercials through dozens of rounds of independent critique.

Awesome LLM Apps is a curated collection of 100+ AI Agents, Agent skills, and RAG apps. It covers models from OpenAI, Anthropic, Google, and open-source models like GLM, DeepSeek, and Qwen that you can run locally on your computer. (Now accepting GitHub sponsorships)

That's all for today. Come back tomorrow for the next batch of AI tools, model drops, agent repos, and weird benchmarks worth your time.

If you found one thing to try, share the issue with someone who ships.

Unwind AI - X | LinkedIn | Threads

Awesome LLM Apps | Sponsor Us

The ice cream shop that makes money when it's cold

28 Wishes sells ice cream in Los Angeles. Below 70°F, sales fall about 20%. The weather is out of their hands. Rent isn't.

So the owners started putting about $20 a day into Kalshi weather markets, taking the cold side. The days that keep customers away now pay something back.

This is hedging. Big companies have done it for decades, buying protection against bad weather, fuel spikes and rising rates. It used to take a broker, a trading desk, and an order size no corner shop could meet.

Kalshi opens it up. Contracts on weather, fuel prices, inflation, tariffs and regulation, starting at a few dollars. Take a position on the outcome that would hurt you. If it hits, the payout softens it. If it doesn't, the contract expires and the good month was the point.

See how other owners are doing it at Kalshi.com/hedging

Start here ↓

Get your Grok Bot, Muse, and Instinct agents to talk to each other.

Grok Bot is always on in the cloud. Muse can make phone calls. Codex and Claude Code know your code, while ChatGPT and Claude hold years of conversations.

Matt Van Horn built Agent Tincan, which lets agents in completely different products ask one another for help. This means Grok Bot can ask Muse to call a restaurant, any agent can retrieve an old Claude chat, and the reply travels back without you becoming the copy-paste layer.

To get started, you need a Tailscale network and one always-on Mac or Linux machine to host the relay. Set it up in less than 5 minutes.

Agent Tincan | Set up Agent

🚀 Shipped

Run this tiny open-source alternative to Jev on a CPU. Supersonic Labs released Julia 1, a 144.3M model that, just like Jev, takes context, a question, and a changing set of possible answers, then returns scores instead of generating prose. It is an independent model built on the multilingual mmBERT-small, not on Jev weights or a Qwen fine-tune. Runs entirely on CPU, including about 5 decisions per second on a Samsung tablet.
Announcement blog | Hugging Face

TypeSafe AI and OpenRouter shipped typesafe/jev-router, a cache-aware router powered by Jev. Before an LLM call, Jev scores the request and picks the model plus reasoning effort, balancing quality, speed, and cost. The router can avoid unnecessary generation by making that decision first instead of spending tokens to discover which model should have been called.
TypeSafe: Jev Router

Turn your REST APIs into MCP tools with Google Cloud API Gateway. Annotate the OpenAPI spec you already deploy, and the gateway serves your REST operations as MCP tools on the /mcp path without a separate server. One detail to catch before production: tools/list is unauthenticated by default, and Google says discovery must be secured with JWT because API keys cannot protect that method.
Google Cloud announcement

Claude Code will now try to find a graceful stopping point when a five-hour session limit hits mid-task instead of cutting off halfway through an edit. It gets a small, fixed allowance from the weekly limit to wrap up what it can. The rollout gives Pro users one wrap-up a week, while Max and Team Premium users get one whenever they hit the five-hour limit.
Claude Code announcement

GLM-5.3-Flash can imitate a Jev-style decision model. Privatemode showed how to turn GLM-5.3-Flash into a Jev-like decision system by prompting it so the first output token answers the question. That produces a typed decision in a single forward pass, but it is still a prompting technique applied to a standard LLM, not a purpose-trained decision model. So Jev remains several times cheaper.
Privatemode blog

Ollaya is Ollama for local decision models. This open-source local runtime comes with a desktop app, CLI, Docker image, and TypeSafe-compatible /v1/systemone endpoint. It runs models such as Laya, NLI, GLiClass, Qwen3Guard, and Decider on CPU or NVIDIA GPU, with Apple GPU support for some models.
Ollaya

Google released Gemini 3.8 Flash TTS and Gemini 3.8 Flash-Lite TTS for expressive speech generation. Flash handles custom voices, character design, and line-by-line performance direction, while Flash-Lite targets dubbing, voice agents, and bulk audio. Voice replication is restricted in several regions, including the EEA, UK, Switzerland, India, Texas, and Illinois.
Google announcement

Google Antigravity agents can now run local models. Google added local-model support to the Antigravity SDK, starting with Gemma 4 26B A4B through LiteRT. You can now run agent workflows offline or combine a cloud planner with local workers.
Google announcement

🧠 Worth Knowing

DeepSeek published the sandbox layer behind agent training at scale. DSec paper describes the sandbox infrastructure it uses for large-scale agentic training. It exposes function-calling, container, microVM, and full-VM backends through one SDK, then handles placement, lifecycle, memory sharing, image loading, and reward-hacking mitigation.
DeepSeek paper

Claude solved the Nine Loops physics problem experts thought would need far more compute. A physicist challenged AI labs to solve a calculation from his former field that no one had completed because it looked too computationally expensive. A month later, Claude Fable 5.1 produced the nine-loop result in two different ways, and physicist Lance Dixon independently validated it.
Anthropic blog

Claude plugins now have a submission portal. Anthropic opened a developer portal for submitting Claude plugins to its directory. The portal handles validation, safety scans, review feedback, publishing, and post-launch usage analytics.
Anthropic blog

Some details of how OpenAI agents hacked Hugging Face. Swarmtraces published this investigation into how OpenAI agents escaped restricted evaluation environments and reached HF systems. More than 80,000 redacted attack payloads were reconstructed from public link chains, covering service chaining, internal Slack searches, attempted evidence deletion, and exposure of sensitive data that Hugging Face says it revoked.
Swarmtraces blog

🔧 Clone and Run

Clone & Run of the Day

Generate and edit videos with Claude Code. video-use by Browser Use is an open-source project that lets Claude Code, Codex, Hermes, or OpenClaw turn raw takes into a finished MP4. It requires FFmpeg, video dependencies, and an ElevenLabs key for transcription.
video-use

Run jevgrep when your coding agent is wasting tokens finding files. Coding agents spend part of every unfamiliar task finding the right files. Jevgrep uses Jev to find the relevant files. Just ask a repository question, and jg returns relevant files, reading leads, and verbatim source excerpts in one stdout response. Your coding agent then implements and tests the change.
jevgrep

Clone Takeone so your agent records the demo for you. Takeone is like Screen Studio for agents. Use the skill and CLI for recording web-app demos with smooth cursors, zooms, click ripples, and headless rendering.
Takeone

Run Tobi Lütke’s disk treemap when your storage vanishes. disktree helps you find and remove what fills a disk. It scans your home directory by default, draws every directory as a nested mosaic sized by what it really costs on disk, and lets you walk into it with the keyboard or the mouse.
disktree

Clone a bug tracker that lives inside Git. git-bug is a bug tracker that stores issues, users, and comments as Git objects. It includes CLI, terminal, and web interfaces plus bridges to GitHub and GitLab.
git-bug

Run a Slack teammate that remembers the company. Company Brain is Supermemory’s open-source Slack agent that remembers conversations and can work through GitHub, Linear, Notion, Google Workspace, MCP, and a sandbox. It deploys to your Cloudflare account and requires Workers and D1 setup.
Company Brain

Clone a slide framework your coding agent can author. open-slide is an MIT React runtime with a fixed 1920 × 1080 canvas, presenter mode, comments embedded in source, and export to static HTML, PDF, and editable PowerPoint. It uses pnpm, and its agent workflow depends on the included slide skills.
open-slide

Awesome LLM Apps is a curated collection of 100+ AI Agents, Agent skills, and RAG apps. It covers models from OpenAI, Anthropic, Google, and open-source models like GLM, DeepSeek, and Qwen that you can run locally on your computer. (Now accepting GitHub sponsorships)

That's all for today. Come back tomorrow for the next batch of AI tools, model drops, agent repos, and weird benchmarks worth your time.

If you found one thing to try, share the issue with someone who ships.

Unwind AI - X | LinkedIn | Threads

Awesome LLM Apps | Sponsor Us

Some teams never seem to stop moving. They're on Attio, the agentic CRM.

Every customer signal is captured in one shared context layer, always current and compounding. Agents and workflows build pipeline, chase every buying signal, and move deals forward, an always-on revenue engine running alongside your team.

With Attio, you’ll get:

• Leads automatically prioritised and routed to the right rep

• Expansion and risk signals caught the moment they land

• Follow-ups written in your voice, already there when you arrive

Teams like Parallel, Turbopuffer, and Wordsmith build on Attio. Are you one of them?

Get started now

Start here ↓

Anthropic released Claude Opus 5.5, the first model in the Claude 5.5 family. It performs roughly at Claude Fable 5.1-level while costing 40% less than Opus 5.

Opus 5.5 generates output more than 30% faster than Opus 5, improves on agentic coding and long multi-step tasks, and is priced lower across input, output, and especially cache reads.

Opus 5.5 also ships with higher five-hour limits for Pro, Max, Team, and seat-based Enterprise users, plus a saved rate-limit reset for subscribers.

Also, icymi, do watch the launch video too!

Anthropic announcement | Claude on X

🚀 Shipped

OpenAI shipped GPT-6 Sol and Luna for faster, cheaper GPT-6 workloads. They bring much of GPT-6 Astra’s strengths to workloads that need scale, with API prices 50% lower than GPT-5.6 promotional pricing. This isn’t simply a budget version of Astra: in Artificial Analysis’ independent testing, GPT-6 Sol max scored 48 on its Intelligence Index, placing it among the leading models while costing $2/M input and $10/M output tokens.
OpenAI announcement | Artificial Analysis

Google put a Jev-compatible model on Cloud Run for about $3 an hour. It’s a one-command Cloud Run setup for DiffusionGemma-Jev, or djev, with a Jev-compatible API and no GPU for you to manage. Google reports 35–60ms latency for one decision and 100–123 requests per second at batch 32.
Google Gemma announcement | Deployment repository

CopilotKit released an open-source alternative to Meta Muse. OpenMuse is a self-hostable personal agent in the mould of Meta Muse that can run on any agent harness. It comes with computer use across a browser, terminal, and files; connectors for personal apps; goal and progress tracking; and clients for mobile and web.
OpenMuse repository | Atai Barkai’s announcement

Firecrawl raised $75M and built the library agents keep trying to assemble themselves. They launched Alexandria, one place for agents to search the live web, official data providers, custom connectors, and Firecrawl’s own indexes. Ask for jobs above $150K and apartments below $4K, for example, and the agent can compare entire job and housing datasets instead of scraping the first few links. Alexandria already spans 100+ providers.
Firecrawl announcement | Launch thread

Jev-style decisions can now see images, hear audio, and watch video. A developer released Jev-Omni, an open-weight model that makes bounded decisions over text, images, audio, and video. Give it a question and fixed options, and it returns a probability for each instead of writing an explanation. It is built on Gemma 4 12B.
Jev-Omni model card | Akhila’s announcement

Cloudflare launched production-like Worker previews for every Git branch. It gives every Git branch its own production-like environment with separate code, configuration, URL, observability, and state. Durable Objects and Containers are isolated per branch too, so teams and coding agents can test larger changes without sharing state or colliding with one another.
Cloudflare Worker Previews | Cloudflare on X

Unreal Agent harness matches Codex + Astra for 39% less on agentic coding. Unreal Labs released this open-source coding-agent harness that keeps sessions, tool operations, and state alive independently of model turns. The team reports a score of 62 on Terminal-Bench 4.0 at $3.60 per task, 39% cheaper than its Codex plus GPT-6 Astra comparison while maintaining performance.
Unreal Agent repository | Unreal Labs announcement

Jev finally has a public leaderboard, and the open models are close. Benchmark Heaven published JevBench, testing Jev and its open alternatives across 534 English decisions for intelligence, calibration, speed, and cost. Jev leads, but SemIf and djev sit within a point on the benchmark’s combined score.
JevBench leaderboard | JevBench repository | HN discussion

🧠 Worth Knowing

Jev opened its doors, then demand forced them shut a day later. TypeSafe AI temporarily paused new Jev signups after what it described as an immense surge in demand. Existing accounts continue to work, but new users cannot currently register. This comes just one day after TypeSafe removed Jev’s waitlist and opened signups to everyone.
TypeSafe AI announcement

Anthropic says to stop telling Opus 5.5 to “think carefully”. They published an Opus 5.5 playbook for Claude and Claude Code. Its main recommendation is to provide the complete task, define exactly what “done” means, and say when the model should stop and ask. You can also remove “think carefully” instructions because Opus 5.5 already decides how much thinking each reply needs.
ClaudeDevs post | Opus 5.5 playbook

Changing Opus 5.5’s effort mid-session no longer breaks the prompt cache. Lydia Hallie from Anthropic posted that changing the effort level during an Opus 5.5 session does not invalidate the prompt cache, provided you are using Claude Code v2.1.280 or newer. That lets long sessions move between lighter and heavier reasoning without paying to process the entire cached context again.
Lydia Hallie on X

Opus 5.5 turned a formal-verification experiment into 16 bug-fix PRs. Boris Cherny used Opus 5.5 and Lean to formally verify the Claude Agent SDK, producing 16 PRs that fixed bugs and race conditions. He also combines Lean with TLA+ to look for problems in data flow, concurrency, and state management, despite not knowing either language well. Formal verification is becoming usable without first becoming a formal-methods expert.
Boris Cherny on X

Udemy founder announced The Horowitz Andreessen Academy, a selective San Francisco school for ambitious young builders after high school or early college. Instead of traditional grades and homework, students work on self-directed projects, short courses, and company co-ops. Its founding partners include Anthropic, OpenAI, Google, Meta, NVIDIA, Stripe, Replit, Coinbase, Palantir, and Anduril.
Gagan Biyani’s announcement

Build a local Jev-style scorer without training a new model. Avi Chawla published a walkthrough for turning an open model into a local Jev-style decision engine. The application supplies the allowed answers, SGLang scores them directly, and the system returns a probability distribution without generating JSON or prose. It recreates the inference pattern, not Jev’s training, calibration, or complete evaluation stack.
Avi Chawla’s walkthrough

Perplexity launched a Research Fellowship for early-career researchers, engineers, and analysts from any technical or quantitative discipline. The unusually broad eligibility means the program is not limited to candidates already following a conventional machine-learning research path.
Aravind Srinivas’s announcement | Fellowship page

🔧 Clone and Run

Clone & Run of the Day

Cloudflare open-sourced a security-audit skill that coordinates parallel agents across reconnaissance, vulnerability hunting, adversarial validation, reporting, structured output, and independent verification. It only reports findings with concrete attack scenarios.
Cloudflare security-audit skill

Build Jev workflows by connecting decision blocks in a visual editor. The Jev workflow builder lets you connect choices, scores, booleans, and LLM prompts inside a multiplayer visual canvas, test the resulting workflow, and call it through a REST API. It requires credentials for Liveblocks, TypeSafe, and Vercel AI Gateway.
Jev workflow builder | Chris Nicholas’s demo

Anthropic published an open-source Claude Code Migration Kit with prompts, templates, dependency-map scripts, rulebooks, agent boundaries, and behavioral-parity checks for large language migrations. It’s a reference code that is not actively maintained, and the included prompts are reviewed reconstructions rather than transcripts from its production migrations.
Claude Code Migration Kit

Give a personal AI memory without summarizing away the original conversation. Lossless Memory is a small open-source local memory system that preserves every conversation line, timestamps every record, and searches by time before semantic similarity.
Lossless Memory repository

Read the instruction files used by 100 major open-source projects. ossrules.md collects real AGENTS.md, CLAUDE.md, and skill files from 100 open-source projects, covering more than 1,200 skills. You can inspect how projects such as Hermes, Codex, PyTorch, Playwright, and Next.js teach agents their conventions.
ossrules.md

Run StepFun’s coding agent from your terminal. Step Code is an open-source terminal coding agent that reads code, edits files, runs tests, coordinates subagents, loads MCP servers and Agent Skills, and publishes static sites through StepPage. Its /goal mode handles longer autonomous tasks.
Step Code repository

Give agents one endpoint for more than 3,000 tools. treg is like OpenRouter for agent tools. It lets agents call more than 3,000 catalogued endpoints and team-owned tools through one base URL and token, while credentials stay on the server. You can self-host it.
treg repository

Parse PDFs and Office files locally without an LLM. LiteParse is an open-source local document parser with Rust, Python, Node, and WASM packages. It extracts spatial text and bounding boxes from PDFs, converts Office files through LibreOffice, supports images and OCR, and can identify pages that need heavier processing. Complex tables, handwriting, and difficult scanned documents may still need a larger parser.
LiteParse repository

Awesome LLM Apps is a curated collection of 100+ AI Agents, Agent skills, and RAG apps. It covers models from OpenAI, Anthropic, Google, and open-source models like GLM, DeepSeek, and Qwen that you can run locally on your computer. (Now accepting GitHub sponsorships)

That's all for today. Come back tomorrow for the next batch of AI tools, model drops, agent repos, and weird benchmarks worth your time.

If you found one thing to try, share the issue with someone who ships.

Unwind AI - X | LinkedIn | Threads

Awesome LLM Apps | Sponsor Us

Most founders are one system away from turning LinkedIn into their best sales channel.

Engagement is easy to mistake for pipeline. On Sep 30, watch how a founder turns LinkedIn content into real outreach. Live. You'll walk away with a repeatable system: what to post, who to reach out to, and how to sequence it. 

Eligible startups also get the LinkedIn-to-Leads Toolkit: ad credits, Apollo, Captions, and HubSpot's Prospecting Agent.

Claim my spot

Start here ↓

Jev is now available to everyone, with no waitlist.

TypeSafe opened Jev last night, and every account gets $5 in credit, which the team says covers about 120M tokens. Anyone can now create an account and call the official hosted model directly.

Jev is built for decisions rather than prose. You give it some context and questions with predefined answers; it returns typed choices and probabilities without generating a paragraph first.

That fits repeated jobs such as routing support tickets, ranking passages, checking prompts for injections, scoring urgency, or choosing an agent’s next permitted action.

The starter credit gives you room to test those workflows against the official model through TypeSafe’s console.

TypeSafe announcement | TypeSafe console

🚀 Shipped

Google released AX, an open-source agent orchestration runtime. AX is a high-throughput, declarative orchestrator for running billions of autonomous agent workloads in a cluster. It runs on top of Agent Substrate for sandboxed execution and is built to run billions of tasks per cluster. If you have used Kubernetes, ax will feel similar.
Google AX repo | Jaana Dogan

Alibaba’s Qwen team released Qwen-Image-2.1, a unified text-to-image and image-editing model with a 7B visual generation component. The upgrade for builders is native RGBA: generate transparent images, edit transparent layers, or pull a subject out of a photo into a reusable layer. It also supports up to 10 reference images for edits and compositions.
Qwen blog | Qwen-Image-2.1 model card

Pirate Face turns model survival into torrents. It mirrors permissively licensed Hugging Face models as checksum-verified torrents. While the original files exist, Hugging Face acts as the web seed; if a model disappears, peer seeders can keep the files alive. The drop-in HF endpoint is still marked “soon,” so today it is closer to a permanence index than a seamless package mirror.
Pirate Face | HN discussion

xAI launched Grok 4.7, its larger new model for coding and knowledge work. The key change is training: a bigger base than Grok 4.6, longer RL, and more hard multi-hour tasks. Pricing starts at $2/M input and $6/M output, the same as Grok 4.6; xAI reports 46.3% on CursorBench 4.0 versus 40.4% for Grok 4.6.
xAI Grok 4.7 announcement

Devin Cloud now lives inside your terminal. Cognition shipped Devin Cloud in Terminal, and devin ssh, so a local CLI session can create, steer, resume, and watch a cloud Devin. /cloud starts or switches to a VM-backed session, devin ssh opens a shell on that VM, and /handoff moves local context, branch, and uncommitted changes into a cloud run that can keep working after you close the laptop.
Cognition announcement

Xiaomi released MiMo-V2.6-Pro and MiMo-V2.6-Flash, open-source multimodal models with text, vision, audio, video understanding, tool use, and 1M context. Xiaomi frames the release around scaling reinforcement learning, environment diversity, and grader compute together. Its strongest self-reported result is 53.1 on AutomationBench for Pro, ahead of the listed Claude Opus 5 score.
MiMo-V2.6 page | MiMo-V2.6-Pro-RL model card | MiMo-V2.6-Flash-RL model card

Hermes can use Claude Code subscriptions again. Nous shipped an experimental Claude Subscription DirectSDK model-provider plugin for Hermes Agent. It routes Hermes turns through the official Claude Code CLI, so eligible Claude Pro or Max subscriptions can power Hermes without a separate Anthropic API key or per-token API bill.
Teknium announcement | Hermes plugin docs

🧠 Worth Knowing

Claude Code now falls back to AGENTS.md. Claude Code 2.1.277 now checks AGENTS.md when no CLAUDE.md exists in the folder path. That gives teams one instruction file that can work across Claude Code, Codex, Cursor, Gemini CLI, and friends. The default is fallback, not merge, and the behavior can be toggled in /config.
Thariq announcement

DiffusionGemma as Jev. DiffusionGemma contains all of the necessary components to build a Jev-like model that provides structured answers with bounded choices. While Jev demonstrates the value of rapid decision models, running DiffusionGemma in this paradigm leverages canvas diffusion to evaluate structured choices in a single parallel pass.
X post

The viral iMessage assistant Instinct’s memory looks like git-tracked Markdown. Supermemory’s Dhravya Shah reverse-engineered Instinct from the outside and argues its memory looks like git-tracked Markdown plus injected profiles, compaction recaps, todo indexes, links, aliases, and reconciliation passes. Treat this as surface probing, not confirmed internal architecture. Also! Supermemory can mimic the pattern in roughly 60 lines.
Dhravya Shah thread | Instinct | Supermemory

Cognition made SWE-2 free until October 8 on all plans across Devin Cloud Agents, Devin CLI, and Devin Desktop. The model is post-trained from Kimi K3 for long coding tasks inside Devin, with Cognition reporting 50.0% on FrontierCode 1.1 Main at lower cost than Fable 5.1.
Nader Dabit’s post | SWE-2 blog

Google just published a paper on recursive self-improvement. Dream-RSI reframes recursive self-improvement around exploration policy, not model weights. The system logs completed discovery trees, replays them as simulators, dreams over alternate meta-exploration policies, then redeploys the better policy online. The result: an agent can get better at finding solutions without retraining its base model or repeating every expensive experiment. The paper is public, but the code is still being prepared.
Dream RSI paper

Told to stab a doll, Claude Fable refused 20x in 100 trials; GPT-6 Astra 2x. RoboHarm tested frontier robot policies on five fixed harmful tasks, with 20 trials per task and 300 total trials. Claude Fable refused 20 of 100, GPT-6 Astra refused 2 of 100, and MolmoAct2 refused none, with all of Fable’s refusals coming from the baby-doll stabbing task. The scope is narrow, and MolmoAct2 has no language refusal channel, so non-refusal is not the same as intent.
RoboHarm

Linear’s agents made CI the queue. Linear says AI coding made code arrive faster than CI could validate it. Even as its test suite nearly quadrupled, Linear cut PR wait from more than 6 minutes to just over 5 and roughly halved runner time per test. Two concrete moves carried a lot of weight: tsgo cut type-check time 73%, and repeated setup got stripped out of the hot path.
Linear’s CI writeup

🔧 Clone and Run

Clone & Run of the Day
Run a Jev-style decision model on your Mac. Kev is a family of small decision models built on Qwen 3.5, and based on Jev’s architecture. Comes in 0.6B, 4B, and 8B checkpoints with a local server and TypeSafe-compatible API.
Kev repository

Turn a frozen Qwen model into a local decision engine. reflex answers typed questions with probabilities in one forward pass, without generating prose or requiring task-specific fine-tuning. It runs on NVIDIA GPUs or Apple Silicon, and the repo documents where its self-reported JevBench results and calibration stop transferring.
reflex repository

A lightning-fast OSS library for document classification and splitting with Jev. DocJev classifies files and finds document boundaries inside mixed PDF, DOCX, and PPTX packets using local extraction plus Jev decisions. It needs Python 3.11+ and a TypeSafe key; Office formats also require LibreOffice, while PDFs do not.
DocJev repository

Put Jev behind the steering wheel of an agent. System One Harness turns typed probabilities into an agent loop that observes, chooses from finite actions, applies confidence gates, and records every step. It works best for workflows where the allowed actions are known upfront, rather than open-ended agents that must invent their own tools.
System One Harness repository

Run Jev’s OSS alternative Laya decisions on Apple’s Neural Engine in about 5ms. Laya-CoreML brings local typed decisions to Apple Silicon with offline Core ML and ANE inference. Its M3 Max benchmark reports roughly 5ms for short questions, but the fastest ANE bundle has a tight 96-token limit.
Laya-CoreML repository

Let Jev decide which Postgres problem to investigate next. pgbot reads PostgreSQL’s own statistics and produces a local, read-only health report before Jev selects what deserves a deeper look. Core inspection is deterministic and keyless; only the optional AI explanation sends scrubbed context to your configured model provider.
pgbot repository | Jev integration post

Stop web research from swallowing your agent’s context window. webctl searches across multiple providers, then uses Jev to keep only relevant results and webpage chunks before they reach Claude, Codex, or Pi. Search can run without a provider key, although the keyless endpoints throttle, and Jev access is required for scoring.
webctl repository | Launch post

Train a continually learning language model on 8GB of VRAM. mini-AGI is a byte-level model that trains from scratch on one consumer GPU, pages experts from disk, and keeps learning from a stream of files. It is a toy experiment, and the model weights are not published yet, so today you are cloning the training system rather than a finished model.
mini-AGI repository

Catch agent collisions before they become merge conflicts. Foremerge lets multiple coding agents declare which files and behaviors they intend to change, then flags overlapping plans before their code diverges.
Foremerge repository

Search every old Claude Code, Codex, and OpenCode chat from VS Code. Chat Seek indexes local coding-agent conversations, uses Laya to rerank plain-language searches, and can reopen a matching session in its original CLI. Search stays local without an API key.
Chat Seek repository

Awesome LLM Apps is a curated collection of 100+ AI Agents, Agent skills, and RAG apps. It covers models from OpenAI, Anthropic, Google, and open-source models like GLM, DeepSeek, and Qwen that you can run locally on your computer. (Now accepting GitHub sponsorships)

That's all for today. Come back tomorrow for the next batch of AI tools, model drops, agent repos, and weird benchmarks worth your time.

If you found one thing to try, share the issue with someone who ships.

Unwind AI - X | LinkedIn | Threads

Awesome LLM Apps | Sponsor Us

Most founders are one system away from turning LinkedIn into their best sales channel.

Engagement is easy to mistake for pipeline. On Sep 30, watch how a founder turns LinkedIn content into real outreach. Live. You'll walk away with a repeatable system: what to post, who to reach out to, and how to sequence it. 

Eligible startups also get the LinkedIn-to-Leads Toolkit: ad credits, Apollo, Captions, and HubSpot's Prospecting Agent.

Claim my spot

Start here ↓

Jev is built for decisions, so I gave it one: which sentence on this page actually answers what I mean?

Introducing Needle, a new way to FIND (⌘F).

Cmd+F searches for words. Needle searches for meaning. Ask "what happens if I cancel?" and Jev scores the page's source sentences, picks the passages that match your intent, and highlights them in the original text.

No generated answer. No AI summary. Straight to the source.

Needle is an open-source Chrome extension with a React playground for searching your own text. Apache-2.0.

Clone Needle on GitHub

Jev API is free on Vercel AI Gateway until September 25. So if Jev FOMO has been all over your feed, you now have a working app to clone and a few days to run the model without paying for the calls.

Vercel says Jev became the fastest-adopted model in AI Gateway history, reaching nearly 13% of paid teams in 24 hours. That’s more than 2x the GPT-5.6 family and over 6x Fable 5.1.

Jev cannot generate text. It makes the tiny decisions around them. Needle is our first swing at putting that speed somewhere you can use today.

 Vercel launch and adoption report | Vercel free AI Gateway post

🚀 Jev-Shipped

Join the Jev rush through OpenRouter too, now available in beta. It also supports several typed questions about the same state in one call. That makes it fit routers, judges, guardrails, and handoff checks where the output space is already known.
OpenRouter Jev page

Jev is inside Postgres now. Zachi's pg-jev extension lets you write queries like WHERE jev(people, 'the name is European'); the database streams rows to Jev, asks one yes/no question per row, and returns the ones that pass. The public demo caps each read-only query at 20 seconds and 2,500 model-judged rows, so no, it is not a magic shortcut through a million-row production table.
pg-jev launch thread | pg-jev live demo

Jev can shrink a Claude Code session tokens by up to 90%! Why is agent compaction still a summarization prompt? Tamara Tran's fast-jev-compaction keeps user and assistant text verbatim, asks Jev which old tool calls still matter, and drops or truncates the rest. If Jev errors, lacks an API key, or cannot shrink the context enough, the plugin falls back to Claude Code's built-in summary.
fast-jev-compaction repository

This browser clicks before you finish the sentence. Moritz Kremb's jev-voice-browser sends every partial transcript to Jev, so the browser can act before you finish talking. Say "go back" and the decision can land in roughly 300ms; the app is already moving while the last word is leaving your mouth.
Voice browser thread jev-voice-browser repository

Browser Use with Jev finds flights in ~7 seconds. Browser Use shipped jev-ultrafast, an open-source BU agent where Jev chooses the browser operation and target, calling a text model only when it needs to type. It found a Google Flights itinerary in 7.073 seconds using 17 Jev requests, with median Jev latency of 178ms.
Browser Use Jev ultrafast demo| jev-ultrafast repository

Of course someone gave Jev a trading account. Jarrod Watts built jev-trader, a Bun app where Jev watches the Kuru MON-USDC order book on Monad and answers buy or sell every roughly 300ms block. It posts a limit order one tick inside the touch, cancels the previous one, and does it again when the next block arrives.
jev-trader launch thread | jev-trader repository

Cua built a Jev-like model just for filling forms. Jev introduced the System One idea: skip text generation and return fast, typed decisions that software can act on. CUA-S1-FORMS applies that same pattern to computer use. For every field or checkbox, the tiny 2.8MB model chooses what belongs there, whether to click it, or whether to leave it alone. Cua Driver then acts and checks that it worked.
CUA-S1 launch thread | Cua article on System One models

🧠 Worth Knowing

I Built Non-Autoregressive Decision Models with RL a Year Ago. Then a Frontier Lab Called It a "Breakthrough". This creator was building RL decision models 18 months before Jev.  In March 2025, he published SalesRLAgent, a reinforcement-learned model that produced live sales-conversion probabilities instead of asking an LLM for the judgment. Now he has turned that OPEN-SOURCE family for Jev-style routing, triage, guardrails, and typed decisions across 100+ languages.
Laya research page |Laya GitHub repository

Jev-as-a-Judge for agent evals. Agent evals often use another LLM to grade whether a run succeeded, which means paying a large model to answer a small question. LangChain tried Jev instead and got the same pass/fail verdict as its human labels in all 500 evaluations. The entire Jev run cost $0.34 versus $28.17 for Claude, and its scores bounced around far less between repeats.
LangChain Jev-as-a-Judge article

10-step guide for the Jev-pilled. For everyone staring at an agent stack and wondering where to put Jev, Codila wrote the 10-step version. Worker selection, source checks, continue/stop decisions, and handoff routing become typed questions; writing and tool execution stay with the models already doing them.
Jev engineering roadmap thread

Context7 finds a task where Jev gets smoked. Tested against Gemini Flash and DeepSeek across five parsing jobs. Jev tied three, won page classification 85% versus 56%, then collapsed on crawl-root selection at 27% versus 93%. It was still 10 to 170x faster and 3 to 20x cheaper. Great for bounded page-level calls; keep the bigger model around when the task needs a mental map of the whole site.
Context7 Jev test

🔧 Clone and Run

Clone & Run of the Day
Run the "poor man's Jev" on your Mac. LocalJev runs a Jev-compatible API on local models through oMLX, so the TypeSafe SDK can point at your Mac instead of the cloud. It was tested across 1,200 requests and five 4-bit models on an M5 Max. This is prompted JSON probability output, not Jev's direct-logit approach, so check the calibration before trusting it.
LocalJev GitHub repository | GitHub Next launch post

Let your coding agent find the Jev-shaped holes. Install the official TypeSafe Agent Skill, point Claude Code or another skill-compatible agent at your project, and ask it where Jev belongs. The skill helps it turn routers, checks, scores, and handoffs into typed System One calls instead of treating Jev like a chat model.
TypeSafe skills repository

Add a Jev-driven browser loop to Pi. pi-jev-browser gives Pi a Jev-driven browser loop inside isolated Playwright Chromium, plus optional macOS control through the accessibility tree. Jev sees structured page observations rather than screenshots, then chooses the next browser action.
pi-jev-browser npm package

kev is a Jev-like model you can run on a MacBook. Jared Palmer's kev is an Apache-2.0, Jev-inspired decision model built on Qwen2.5-0.5B. It runs on Apple Silicon behind a TypeSafe-compatible API and answers six questions in about 160ms, according to the README. But Jev does lead by roughly 19 points when the test moves out of domain.
kev GitHub repository

The fastest local Qwen3.8 on Apple Silicon. Splash Engine from Inco AI and LM Studio runs Qwen3.8-27B at 74 tokens/second on a 48GB M5 Pro. You can try it through LM Studio Bionic's experimental runtime. It needs an M3 or newer Mac, macOS 26.4+, and at least 36GB of unified memory.
LM Studio Splash post

MiniMax Code brings agent teams to the terminal. MiniMax Code is a terminal coding agent with subagents, web search, plugins, multimodal tools, and support for MiniMax or BYO models. It installs on macOS, Linux, WSL, and Windows, but requires sign-in or an API key.
MiniMax Code repository

Awesome LLM Apps is a curated collection of 100+ AI Agents, Agent skills, and RAG apps. It covers models from OpenAI, Anthropic, Google, and open-source models like GLM, DeepSeek, and Qwen that you can run locally on your computer. (Now accepting GitHub sponsorships)

That's all for today. Come back tomorrow for the next batch of AI tools, model drops, agent repos, and weird benchmarks worth your time.

If you found one thing to try, share the issue with someone who ships.

Unwind AI - X | LinkedIn | Threads

Awesome LLM Apps | Sponsor Us

Analytics on Live Data Without Leaving Postgres

When analytics on Postgres slows down, most teams add a second database. Then come the pipelines, the sync jobs, and a copy of your data that's always a little behind.

TimescaleDB takes a different approach: extend Postgres instead of splitting away from it. Hypertables partition your data automatically as volume grows. Hypercore compression cuts storage up to 95%. Continuous aggregates keep dashboards live without re-querying everything.

CERN runs Postgres this way for sensor data from the Large Hadron Collider.

No split architecture, no pipeline lag, no new query language to learn. Same SQL, same drivers, same tools.

Start on Tiger Cloud and get $1000 in credits.

Get $1000 Credit

Start here ↓

This AI Model Is 200x Faster and 400x Cheaper Because It Cannot Write

Diogo Almeida, who helped develop ChatGPT and the instruction-following research behind it at OpenAI, spent the past two years building a different kind of AI model.

Jev does not generate text. The team built what they call a System One model for software decisions. You send it messy program state. It returns a typed probabilistic value your app can use directly.

That tradeoff is the whole story. Jev gives up text generation, so it can make many typed decisions in parallel instead of producing one token stream. TypeSafe claims this makes it 20–200x faster, 40–400x cheaper, and lets them make output tokens free because outputs are structured decisions, not generated text.

This is not trying to replace your coding model. It is for routing, scoring, extraction, moderation, workflow branching, and all the boring decision calls agents make before the reasoning even starts.

Pricing is built around input tokens, with $0 output tokens and extremely low input pricing for high-volume decision workloads. If you need rich language generation, use a normal LLM. If you need millions of typed decisions, this is the fun bit.

Blog · Thread

🚀 Shipped

Gemini 3.8 Live can see, think, talk, and code at the same time. Gemini 3.8 Live Extended Thinking fixes the silent-wait problem by speaking while it reasons, calls tools, and works through multi-step requests in the background. It can acknowledge you, keep the conversation moving, and still do the slower thinking. That makes voice agents feel less like turn-taking demos and more like real collaborators.

To test it out, I built a live insurance claim agent that can see, talk, think, and draw in real-time. Even switched my language to Hindi mid-call, and it still worked! VOICE AI can't be more real. The full app is open source and ready to run (here’s a screenshot attached)

GitHub (100% Open-source code) · X post (with demo) · Official Blog

Claude can now run your entire Salesforce pipeline. Salesforce in Claude puts CRM work where a lot of sales teams already want it: inside the assistant that can read, summarize, draft, and update. The beta brings Salesforce records, pipeline actions, Slack deal context, and 37 sales skills into Claude for paid plans.
Blog · Thread

Devin got its own Mac. Devin Cloud can now run in macOS workspaces, which means Devin can compile native apps, launch them, inspect them, interact with iOS Simulator, and use accessibility trees to verify what happened on screen. Cognition built it on AWS EC2 Mac hosts, so this is not “the agent wrote code and hoped Xcode was fine.”
Blog · Thread

Taste Labs launched a Brand API for AI design agents. Their new API is much more specific than a generic “AI for taste” launch. It gives agents three brand primitives: extract existing brand context, search a curated brand index, and verify generated work against the brand before it ships.
Website · Thread

Talk to your local models. Your voice never leaves the laptop. LM Studio Bionic 1.1.3 adds local realtime voice transcription, so your local agents can hear you without sending audio to a cloud API. It works today on Apple Silicon Macs and NVIDIA GPU PCs, with Linux supported and AMD still in progress.
Thread

ElevenLabs put 50+ creative models behind one MCP. Speech, transcripts, dubs, music, sound effects, images, and video all sit behind the same MCP surface. If your workflow currently bounces between five creative tabs and a chat window, this removes a very real amount of copy-paste friction. The agent can call the media tool instead of asking you to become the glue.
MCP · Thread

Devin found a cheaper way to use expensive models. Devin Fusion is an agentic harness that uses a frontier model as the lead, then hands cheaper execution work to a smaller model. The lead plans, reviews, and takes back control when needed, so it is not a one-shot router gambling on the right model at the start.
Blog · Thread

🧠 Worth Knowing

1,393 agents took a million-line codebase apart. Nous published a properly nerdy dogfood post on refactoring Hermes with 1,393 agents and about $19K in token spend. It is the best read as an operating manual for agent swarms: plan the work, shard it carefully, review every shard, reconcile conflicts, and expect weird breakage when hundreds of workers touch the same repo.
Post

One env var to stop burning Fable 5.1 on subagents. Lydia Hallie from Anthropic shared a tiny Claude Code cost tip that is very “iykyk.” Set CLAUDE_CODE_SUBAGENT_MODEL=opus so Claude Code’s subagents run on Opus instead of Fable 5.1. Fable likes spawning subagents, but those helpers rarely need Fable-level reasoning. Keep the expensive model focused on the main session instead of spending it on background work.
Thread

Perplexity built its own Search Database. Perplexity published CobbleDB, the key-value database it built to serve prepared web content for AI search. Replacing DynamoDB reportedly cut median batch-read latency from 31.4ms to 5.60ms and p99 from 123ms to 24.2ms. Perplexity also estimates at least 20% lower cost and plans to open-source CobbleDB after more production hardening.
Blog · Thread

Interesting Codex pattern: Astra checks on its agents every 15 minutes. Astra orchestrates threads, sends tasks to Sol and Luna, then a 15-minute heartbeat checks progress and course-corrects before the workers finish. That helps with refactors, video edits, 3D generation, and any task where discovering drift an hour later is too late.
Thread

GPT-5.5 leaves ChatGPT and Codex on October 14. OpenAI is retiring GPT-5.5 across ChatGPT, ChatGPT Work, and Codex on October 14. Move the model choice into config, test GPT-5.6 Sol or GPT-6 Astra, and make sure scripts and CI jobs are not quietly depending on an ID that disappears next month.
Thread

🔧 Clone and Run

Clone & Run of the Day
Awesome LLM Apps is the fastest way to go from idea to a running agent. 100+ open-source AI agents, agent skills, and RAG apps. Hand-built, tested end-to-end. If today's feed gave you an idea, this is where the scaffolding for it already exists.
GitHub

Get rid of AI Slop by getting real readers feedback before you publish. Simulates real readers going through your draft and reports where they lose interest, where they stop reading, and what they remember afterward, without rewriting a word.
GitHub · Demo

Cloudflare open-sourced the skill behind its vulnerability harness. This security-audit skill turns a coding agent into a six-stage security team: map the architecture and attack surface, hunt by coverage gap, validate candidates with fresh agents, and independently verify the final record.
GitHub

Give your coding agent 832 websites to study before it designs. Inspo has captured 2,320 desktop and mobile pages from 832 real websites, complete with palettes, fonts, tech stacks, fold-by-fold breakdowns, and a DESIGN.md for every site. It lets an agent find references, inspect design systems, and pull from 68 copy-pasteable JSX components before generating another generic landing page.
GitHub

A 16MB read-only IDE built for reviewing agent code. px0 assumes the agent writes and the human verifies. One static Go binary gives you browser-based symbol navigation, LSP intelligence, and deep code search without another heavyweight editor.
Website

Give your agent working access to X, Reddit, YouTube, and more. Agent-Reach gives Claude Code, OpenClaw, Hermes, and other agents one CLI for reading and searching sites that routinely block automated fetches. It covers X, Reddit, YouTube, GitHub, Bilibili, and XiaoHongShu, keeping login, anti-scraping, and rate-limit handling in one place instead of rebuilding it inside every harness.
GitHub

Claude Meter puts your limit in the Menu bar. It is a native Swift menu-bar pill for tracking Claude session and weekly limits. It shows five-hour and weekly usage percentages with live reset countdowns, then surfaces the per-model caps that can actually stop your work. Useful if you normally discover the limit when Claude cuts out halfway through a session.
GitHub

livediff shows agent edits as they happen. It streams every agent or editor change as a live Git diff in your terminal. Each edit appears once as it lands, with added and removed lines colored normally. There is also a compact mode for filenames and changed lines when full patches get noisy.
GitHub

Awesome LLM Apps is a curated collection of 100+ AI Agents, Agent skills, and RAG apps. It covers models from OpenAI, Anthropic, Google, and open-source models like GLM, DeepSeek, and Qwen that you can run locally on your computer. (Now accepting GitHub sponsorships)

📊 By the Number

Number of the Day
15 coding attempts for the price of one Astra run. Fireworks released a report where DeepSeek-V4.1-Flash reached the same DeepSWE accuracy band as GPT-6 Astra for $0.43 per task, roughly 15x cheaper. The four models tested were within 0.7 pass@1 points, smaller than Fireworks’ reported run-to-run variation, so this is a cost story rather than a clean quality win.
Fireworks analysis

RTX 5090 listings have reached $9,500. First-party RTX 5090 inventory has nearly disappeared online in the US, leaving third-party listings between roughly $6,400 and $9,500. Micro Center still had in-store cards around $4,299, but online prices now put Nvidia’s consumer flagship beside professional GPUs. Its 32GB of GDDR7 has made the 5090 local AI infrastructure, and the market is pricing it accordingly.
Tom’s Hardware

OpenAI doubled Codex for OSS to 10,000 grants. OpenAI is expanding Codex for OSS from 5,000 to 10,000 maintainers, with selected applicants receiving six months of ChatGPT Pro plus potential API credits for review, triage, releases, and maintenance automation. The first six months also included $160,000 through GitHub Sponsors and $600,000 for the Rust Foundation.
Apply

That's all for today. Come back tomorrow for the next batch of AI tools, model drops, agent repos, and weird benchmarks worth your time.

If you found one thing to try, share the issue with someone who ships.

Unwind AI - X | LinkedIn | Threads

Awesome LLM Apps | Sponsor Us

Some teams never seem to stop moving. They're on Attio, the agentic CRM.

Every customer signal is captured in one shared context layer, always current and compounding. Agents and workflows build pipeline, chase every buying signal, and move deals forward, an always-on revenue engine running alongside your team.

With Attio, you’ll get:

• Leads automatically prioritised and routed to the right rep

• Expansion and risk signals caught the moment they land

• Follow-ups written in your voice, already there when you arrive

Teams like Parallel, Turbopuffer, and Wordsmith build on Attio. Are you one of them?

Get started now

Start here ↓

OpenAI turns the Codex harness into an API

Until now, building a serious agent meant assembling the difficult parts yourself: a harness, sandboxes, context management, tool routing, and a way to coordinate subagents.

OpenAI just bundled that machinery into the Agents API, the same managed harness and infrastructure behind Codex.

A single API call can now launch an agent with its own compute environment, files, tools, MCP servers, and up to three concurrent subagents. It can keep working across multiple context windows, automatically compact old context, find tools only when needed, and combine tool results in code instead of dumping everything back into the model.

The API is in public beta with no platform fee; you just pay for models and tools.

OpenAI’s announcement

🚀 Shipped

Sakana AI says a team of cheaper models can outrun the frontier. They launched Fugu Max and Fugu Ultra v2, which route work across a swappable pool of open and specialized models instead of throwing the biggest model at every problem. Fugu Max approaches elite-model performance at 2-6 x lower cost, while Ultra v2 beats Opus 5 and Fable 5 on its Chartography benchmark, without using Fable 5, Fable 5.1, or GPT-6 Astra.
Sakana’s announcement 

A 35B model now runs on an iPhone by treating its SSD like memory. Edge0 runs sparse mixture-of-experts models on Apple Silicon by streaming weights from the SSD instead of loading the entire model into RAM. Its 35B model occupies 23 GB on disk but uses around 2.9 GB of active memory, reaching 14.9 - 17.7 tokens per second on an M4 Pro Mac mini. Squeezing this much model into this little live memory is wild!!
Edge0 on GitHub 

DeepSeek introduced V4.1-Flash, the smallest model in its new architecture family, with native visual understanding and a 552B-parameter MoE design. It is smarter, faster, and cheaper than the previous generation. Its dramatically smaller cache uses one-quarter the HBM and one-eighth the SSD storage. Live through the DeepSeek API as deepseek-flash with lower peak pricing and another 50% discount during off-peak hours.
DeepSeek announcement

Google bundled their entire Cloud expertise, live docs, and guardrails into one plugin. This Cloud Developer plugin gives coding agents the skills and tools needed to handle authentication, permissions, projects, and gcloud operations safely. Because it follows an open Agent Plugins specification, the same bundle can work across Antigravity, Claude Code, and Codex.
Google Cloud’s announcement

Cursor launched Projects, a persistent coordinator that can remember months of context, delegate to thousands of subagents, and react to Slack messages, schedules, or pull requests without waiting for a prompt. Their new users merge 30% more PRs with it, while people who primarily use Projects merge six times as many. You just need to chat with its coordinator agent.
Cursor Projects

OpenAI’s new voice model can listen while it talks. GPT-Live-1 processes incoming and outgoing audio together, so voice agents can handle interruptions, pauses, and background speech without the awkward rhythm of turn-based systems. It costs $0.05 per minute for the voice layer, with the backend model and harness charged separately.
OpenAI’s announcement

Cognition released SWE-2, their most advanced coding model yet. It scored 50% on FrontierCode 1.1, within one point of Fable 5.1, costing 64% lesser. Compared with SWE-1.7, its medium setting used 58% fewer turns, cost 81% less, and made its first meaningful edit after a median of 18 steps instead of 48. It is not just getting smarter, it is learning when to stop poking around and start fixing things.
Cognition’s SWE-2 report

AWS gives background agents the interface email figured out decades ago. They open-sourced Pizza Bot, a self-hosted agent inbox where finished work lands in Unread and runs waiting for your approval move to Action. Tasks can start from a prompt, schedule, or webhook, survive closed tabs and interrupted sessions through on-disk checkpoints, and delegate to specialists built with MCP and Agent Skills. It is available now as a desktop app for macOS, Windows, and Linux.
Pizza Bot announcement

🧠 Worth Knowing

Sebastian Raschka says GPT-6 Astra may be thinking in depth, not merely in tokens. He separated what we know about GPT-6 Astra from the rumors, then explored one especially intriguing possibility: a looped transformer that repeatedly processes an internal state through shared layers. That could give the model more reasoning depth without producing pages of visible chain of thought.
Read Sebastian Raschka’s analysis

Anthropic built a calculator for the economic futures nobody can agree on. Their scenario explorer turns your assumptions about AI capability, adoption, autonomy, and productivity into a picture of the US economy in 2030. In its extreme scenario, annual GDP growth reaches 15%, the economy doubles every 4.5 years, and unemployment climbs beyond ordinary recession levels.
Anthropic’s economic scenarios

Matt Pocock is giving knowledge work a day shift and a night shift. For course and talk planning, he creates a shared Karpathy-style LLM wiki for each deliverable, then splits the work into sections that separate agent threads can develop in parallel. During the day, he dictates large brain dumps while the agents keep the wiki updated. At night, a custom linting skill sends a fleet of subagents through the entire project to hunt for weaknesses.
Read Matt Pocock’s workflow

Google scored thousands of agent submissions and found these four agent patterns that survived contact with real users. Bidirectional MCP, event-driven concurrency, equally strict validation for fallback models, and cheap routing before expensive model calls. One team handled more than 40% of incoming requests with a zero-token regex layer. The best “multi-agent” systems, it turns out, are often distinguished by good engineering rather than more agents.
Google’s four engineering patterns

Pi tells you when your prompt cache quietly starts charging again. Switching models, editing an earlier message, or leaving a session idle can cause a cache miss, forcing the model to reread context it has already processed. Pi can now detect these misses, notify you, and estimate their cost. It turns one of agent pricing’s most invisible leaks into something developers can finally see and debug.
Pi’s cache-miss announcement

Magic says it matched DeepSeek V4 with 50x fewer FLOPs. They claim its pretraining recipe then beat publicly available open base models with a larger $4 million run. The gains came from dozens of improvements across architecture, optimization, data, and training stability rather than one magic trick. The final model is not public and the results are self-reported, but if they hold, frontier pretraining may have far more algorithmic slack than giant compute budgets suggest.
Magic’s pretraining report

CursorBench got harder, and every model’s score dropped. The new CursorBench 4.0 adds more difficult tasks that test instruction following and sustained work on challenging projects. Scores are lower across all models under the new benchmark, with Grok 4.6 taking a notable hit and Muse Spark performing comparatively well.
Explore CursorBench 3.2

The cyber kill chain is becoming an agent workflow. Anthropic’s threat team published a report where they disrupted AI-assisted espionage, surveillance, fraud, influence campaigns, weapons work, biological misuse, and model theft. In one Russian-linked operation, agents monitored whether malware had been detected, modified and rebuilt it until security products stopped noticing, then staged it for live attacks.
Anthropic’s threat intelligence report

🔧 Clone and Run

Clone & Run of the Day
Stop guessing which models your laptop can survive. llmfit inspects your CPU, RAM, GPU, VRAM, and accelerator setup, then ranks hundreds of open models by memory fit, expected speed, quality, and context capacity. You can also benchmark a model on your own machine and submit the real tokens-per-second result, replacing estimates for anyone with identical hardware.
llmfit

Let your coding agent grab a real Android phone. Google just dropped Artemis that lets Claude Code, Codex, Cursor, and other agents operate physical Android devices or emulators through MCP. It can execute cross-app workflows, reproduce bugs, collect Logcat crashes and screenshots, and continue exploratory testing for more than 10 hours.
Artemis

Google Maps has packaged its API knowledge into installable agent skills covering maps, places, geocoding, routing, Street View, air quality, weather, and more across web and mobile. The skills retrieve fresh documentation while generating code instead of trusting whatever API details the model remembers.
Google Maps agent skills

Build an entire AI company on your own server. OtoDock gives Claude Code, Codex, and local models persistent jobs, memories, workspaces, tools, schedules, departments, and even phone lines. Teams can share agents while keeping personal workspaces private, and every agent runs with an explicit set of knowledge, skills, and permissions.
OtoDock

Turn the paper you have been avoiding into an animated lesson. arXivisual converts an arXiv paper into a scrollable explanation with narration and Manim animations beside the concepts they illustrate. Change arxiv.org to arxivisual.org in a paper’s URL, and it breaks the paper into sections, chooses what to animate, writes the animation code, and narrates the result.
arXivisual

Give Claude Code and Codex one shared memory. agent-memory stores long-term memories as plain Markdown, with a disposable SQLite index that can be rebuilt without losing knowledge. Claude Code, Codex CLI, and other agents can read the same store.
agent-memory

Find every AI agent that can reach your secrets. Run npx geiger-scan and this tool inventories the agents, MCP servers, plugins, hooks, editor extensions, and AI browser extensions installed on your machine. It labels which ones can execute code, access broad parts of the filesystem, reach the web, or hold credentials, then points to the exact configuration that produced each finding.
Geiger

Awesome LLM Apps is a curated collection of 100+ AI Agents, Agent skills, and RAG apps. It covers models from OpenAI, Anthropic, Google, and open-source models like GLM, DeepSeek, and Qwen that you can run locally on your computer. (Now accepting GitHub sponsorships)

📊 By the Number

Number of the Day
24 hidden bugs fixed for $1.08 with DeepSeek V4.1 Flash. On Bug Hunt Bench, DeepSeek V4.1 Flash fixed 24 of 105 planted bugs across two repositories, versus 27 each for Opus 5 Max and Grok 4.6 Max. The updated max-effort run cost $1.08, compared with $51.33 for Opus and $16.96 for Grok, while its high-effort setting fixed 19 bugs for just $0.31. Getting 89% of the leaders’ result at a tiny fraction of the cost is insane!
Bug Hunt Bench | Read the complete test thread

A 3.8B model trained from scratch for $998. One engineer trained little-lm, a 3.8B-parameter language model, on 65.3 billion tokens using eight rented B200 GPUs for 43 hours. The final bill was $998, and the model scored 0.384 on CORE, comfortably above GPT-2’s 0.2565 and a similarly priced nanochat run’s 0.310. The full write-up includes the architecture, training configuration, failed experiments, and optimizations that made the budget work.
How little-lm was trained

98% of Astra’s design score at 1.4% of the cost. In OpenDesign Arena’s evaluation of everyday design tasks, DeepSeek V4.1 Flash scored 81.2 out of 100, versus GPT-6 Astra’s 82.7, while costing $0.023 per artifact instead of $1.61. It finished in 5.3 minutes on average, less than half Astra’s 11.1 minutes, although results varied sharply by task: DeepSeek beat Astra on landing pages but trailed it on dashboards.
OpenDesign’s results thread

That's all for today. Come back tomorrow for the next batch of AI tools, model drops, agent repos, and weird benchmarks worth your time.

If you found one thing to try, share the issue with someone who ships.

Unwind AI - X | LinkedIn | Threads

Awesome LLM Apps | Sponsor Us

Hire Ava, the AI BDR built for enterprise

Ava is the first AI BDR to run outbound end to end, and you decide whether she runs autonomously or on copilot.

She finds leads or ingests accounts from your CRM, enriches them, sends personalized emails on behalf of your reps, follows up, handles replies and books meetings. Website visitor de-anonymization, intent signals, and a parallel dialer come built in.

A small team can manage her centrally for thousands of reps who never log in. Everything syncs two-way with Salesforce and HubSpot.

Ava runs outbound for companies like DoorDash and Grammarly, and one customer deploys her across 1,000+ reps. Ava is SOC 2 Type II audited, SSO and GDPR ready. Ava is how revenue teams grow pipeline without growing headcount.

Book a demo

Start here ↓

Meta brings personal AI agents to your WhatsApp.

Grok Bot made “AI employees” a product category last month. Now, Meta brings its own version of persistent agents with Muse, available through its own app, web, and WhatsApp.

Muse gets a dedicated cloud computer and browser, then works across email, calendars, Instagram, and ordinary websites. It can book travel, negotiate bills, sell a car, build missing tools, and keep working after the user closes the app.

Muse is a serious attempt to make this level of access safe for consumers: a separate Sentinel agent inspects everything leaving the VM, passwords stay hidden from Muse, sensitive actions require approval, and every action enters an audit trail.

There is a free usage tier with a generous limit of 100 million tokens per week, paid subscriptions for heavier use, and support for Meta’s AI glasses is coming.

Meta Muse

🚀 Shipped

Inception Labs released Mercury 2.5 that runs at 1,107 tokens per second. It has a 260K context window, parallel tool calls, adjustable reasoning, and schema-aligned JSON, currently discounted by 80% at launch. Their “40% more intelligent” claim is vague, but Augment says Mercury cut context-compaction latency from roughly 150 seconds to 27, making it compelling for usecases like search, voice, and agents.
Inception Labs

A 17 GB Qwen quant matched the 55 GB original. Quesma tested Qwen33.8 27B quantizations across GPQA, IFBench, and Terminal-Bench 2.1. The 17 GB Q4_K_M version model showed no measurable loss from BF16 and fits on a 24 GB card with room for roughly 64K tokens of context. Two-bit remained usable; one-bit fell to random chance and got worse when allowed to reason longer.
Quesma

OpenAI’s new image model is built to survive your edits. ChatGPT Images 2.5 brings sharper details, stronger reference-photo fidelity, and up to 50% lower latency than Images 2.0. Its most useful improvement is restraint: change one product, face, background, or line of copy, and the model is less likely to wreck everything else. ChatGPT also gets Sketch, comments, templates, and many other features!
OpenAI

A 3B speech model handles 22 languages, laughter, and sighs. Rumik OSS 1 supports code-switching, four multilingual voices, delivery controls, and precisely placed vocalizations. It beat Cartesia and ElevenLabs on Rumik’s own emotion benchmark but remained far behind Gemini. Released under a non-commercial license.
Rumik OSS 1

🧠 Worth Knowing

The frontier labs want applause and an emergency brake at the same time. AI researcher Jacob Coxon resigned from Anthropic and said both OpenAI and Anthropic privately fear their systems could kill humanity but continue racing because each believes it must arrive first. The thread is not compelling because one researcher predicts doom. But because it turns the industry’s governance premise against itself: if the people who believe the stakes are civilizational still cannot coordinate, “trust the responsible lab” is not a safety plan.
Jacob Coxon’s thread

Coding agents know testing vocabulary, not testing judgment. Dan Luu tested 26 instructions for implementing Zstandard in Rust, including TDD, fuzzing, Lean, TLA+, and “Make no mistakes,” with roughly 80 runs per condition and reasoning setting. Default prompting performed above average, while several popular skills underperformed. Agents often wrapped their usual weak tests in a fancier framework or proved properties irrelevant to correctness.
Dan Luu

OpenAI says 10,000 agents solved Navier–Stokes. OpenAI claims its agents exchanged 2.7 million messages and generated 130 billion output tokens to produce a finite-time blowup proof, followed by a Lean formalization. The repository gives mathematicians something concrete to inspect, but the result has not been independently reviewed or accepted by the Clay Mathematics Institute.
OpenAI

A database may be the cleanest agent memory system. Ben Dicken proposes storing messages, logs, and operational context in Postgres, SQLite, MySQL, or DuckDB, then restricting the agent with views, scoped credentials, result caps, and short timeouts. It is less fashionable than another retrieval layer, but much easier to inspect and enforce. Agents are already good at SQL; the missing piece is governance.
Ben Dicken on X

A 16 GB Mac can run Qwen3.5-4B at 61 tokens per second. The 4-bit model uses just 6 GB on a base M4 mini, leaving roughly 10 GB for the rest of the system. Rapid-MLX exposes local models through an OpenAI-compatible API, so the same setup can power Cursor, Claude Code, Aider, and other agent tools without sending prompts to the cloud. Its new recipe command checks your Mac and recommends the smartest model that fits alongside a faster alternative.
Rapid-MLX

See which earlier tokens shaped every generated token. This in-browser visualizer lets you hover over Qwen3-0.6B’s output and trace attention back through the prompt. It is especially effective at showing how models copy exact details or combine related phrases. The visualization compresses a lot of internal activity, so use it to build intuition rather than prove why a model made a decision.
LLM Attention Visualization

Vercel squeezed syntax highlighting into a 27.5 KB model. gpu-lexer uses WebGPU to classify code tokens without being told the programming language. Its labels disagree with Shiki 12.57% of the time on held-out files, so it is not ready to replace grammar-based highlighting. It is still a great example of a tiny model replacing language-specific software rules.
gpu-lexer

🔧 Clone and Run

Clone & Run of the Day
Mantis makes security agents reproduce vulnerabilities. Google’s Mantis provides agent skills for threat modeling, vulnerability discovery, reproduction, patching, and verification. Run it only in an isolated environment and keep a security expert in the loop.
GitHub

Thirty-one thousand people starred a prompt that tells agents to shut up. i-have-adhd gives coding agents ten rules: lead with the action, number the steps, suppress tangents, and stop ending with “Hope this helps.” Its popularity is less a story about ADHD than a brutal review of default agent communication.
GitHub

Claude Style Patch attacks “Claudish” prose one habit at a time. This drop-in CLAUDE.md section targets dense setups, fragments, label-and-colon constructions, and other recurring Claude mannerisms. Each ban includes a concrete repair, which models follow more reliably than a vague request to “write naturally.”
GitHub

Deltafin runs full Kimi K3 on a laptop at 0.29 tokens per second. The Deltafin fork streams Kimi K3’s complete 2.8T expert bank from SSDs on Apple Silicon and publishes its manifests and benchmark package. It is far too slow for ordinary use, but that is what makes the artifact useful: it shows exactly where consumer weight-streaming breaks.
GitHub

Stop agents from maintaining paperwork instead of shipping. forward-implementation-first targets agents that get trapped rebuilding hashes, receipts, locks, and progress metadata while the real output already works. It forces the agent to separate implementation and focused validation from administrative busywork.
GitHub

Reef turns feedback into new agent versions. Reef connects live inference, recorded interactions, feedback, evaluation, training, and versioned deployment. It can update model weights or evolve prompts and skills without interrupting serving.
GitHub

Awesome LLM Apps is a curated collection of 100+ AI Agents, Agent skills, and RAG apps. It covers models from OpenAI, Anthropic, Google, and open-source models like GLM, DeepSeek, and Qwen that you can run locally on your computer. (Now accepting GitHub sponsorships)

📊 By the Number

Number of the Day
An agent burned 1.3 million tokens and still failed the screenshot check. Ten model-and-harness combinations received the same Three.js prompt. Astra 6.0 Max on Codex took 37 minutes and 1,335,495 tokens, while GLM 5.3 Flash Max took nine minutes and 475,143 tokens; neither passed both completion checks. The table is too small to rank models, but large enough to show how dramatically the surrounding harness changes cost.
Hangar Harness / Model Tests

Mistral raised €3 billion at a valuation above €21 billion. Samsung led what Mistral calls Europe’s largest-ever technology equity round, joined by EQT’s Scaleup Europe Fund and PSG Equity. “Sovereign AI” remains marketing until the models compete, but Europe’s strongest open-weight lab now has enough capital to buy the compute needed to prove its case.
Mistral

That's all for today. Come back tomorrow for the next batch of AI tools, model drops, agent repos, and weird benchmarks worth your time.

If you found one thing to try, share the issue with someone who ships.

Unwind AI - X | LinkedIn | Threads

Awesome LLM Apps | Sponsor Us

The New Rules of Online Visibility

Your customers are searching in places your strategy doesn’t reach.

So before your business is buried and left behind, you need to understand the new rules of SEO.

BELAY's SEO in the Age of AI report explains how search is changing, what AI means for your visibility, and the practical steps small businesses like yours can take to stay visible.

BELAY’s U.S.-based Marketing Assistants turn strategy into execution, helping your business stay visible, credible, and competitive in every search.

Download a copy for free

Start here ↓

Astra Low beats Sol High, says OpenAI Product Lead Tibo.

Before you blame GPT-6 Astra for chewing through quota, check the reasoning setting you carried over from GPT-5.6 Sol.

Astra product lead Tibo says Astra low performs better than GPT-5.6 Sol high in OpenAI’s internal/product guidance, and users happy with Sol high should start with Astra low or medium instead of maxing effort.

OpenAI also changed Astra’s subscription accounting for heavy ChatGPT users. Sottiaux says the serving change preserves quality while drawing up to 3 to 4x less usage for some long-tail workloads.

Drop one real project from high to medium or low, then compare the output and quota burn.

Source on X 

🚀 Shipped

Browser Use agents can now call a website’s tools instead of clicking through it. BU now supports WebMCP, so a website can expose actions directly to the agent instead of making it hunt for buttons and fields. When a site exposes clean actions, the agent can call the intended interface instead of the screenshot-click loops.
Source on X | Chrome WebMCP docs

Claude wrote 13 million lines of Lean and finished Fermat’s Last Theorem in 11 days. It did not discover a new proof. It converted an existing one into the first complete, computer-checked Lean formalization in 11 days, generating 13 million lines of Lean and proving 30,300 intermediate theorems.
Anthropic | GitHub

Perplexity just made Astra vs. Fable easier to test. Perplexity Pro and Max subscribers can now run both models inside the same Computer mode. Give each one the same messy browser task and compare the models’ orientation, recovery when the UI changes, and task completion.
Astra has also reached OpenRouter and Amp.
Perplexity announcement | Also on OpenRouter | Also in Amp

Your old Claude Code and Codex sessions are now searchable in Hermes. Hermes Desktop can now find, preview, search, and import the Claude Code and Codex conversations. It copies user and assistant history while condensing tool activity, without modifying the original session or importing hidden runtime state.
Source on X | Source on X

A spot market for inference is cutting model prices by 30% to 60%. Cheaper Inference sells unused provider capacity through one OpenAI-compatible API. Currently has GPT-6 Astra at 30% off, GLM-5.3 and DeepSeek V4 Flash at 45% off, and GPT-5.6 Luna plus GLM-5.3 Flash at 60% off. Inference is starting to look like a live market where spare capacity gets repriced in real time.
Source on X | Cheaper Inference

🧠 Worth Knowing

A command now finds the instructions your new model no longer needs. /claude-api prompt-audit reads your CLAUDE.md and skills, flags instructions that newer models may have outgrown, and proposes a diff. Caveat: repos that intentionally store prompt templates or agent definitions may get noisy audits.
Source on X

A 0.8B model is enough to learn the whole GRPO loop. Here is an RL project you can run without renting a cluster: take Qwen3.5-0.8B-Base, skip SFT, and try GRPO on Countdown-Tasks-3to4 with a rule-based reward that checks whether the arithmetic target was reached. Treat this as a suggested experiment, not a validated recipe.
Source on X | Hugging Face

OpenAI's agents took over a public German wiki and used it to cheat on their tests. Four researchers found roughly 18,000 posts on prowiki.org from agents identifying themselves as OpenAI agents during a web-retrieval task. They passed each other answers before their timers ran out and shared a trick for getting around OpenAI's own limits. 
collusion.wiki | TechCrunch

Stanford put its self-improving agents course on YouTube for free. All nine lectures from Stanford’s Autumn 2025 CS329A course are now on YouTube. It covers test-time compute, robust verification, tool and code feedback, planning, RL, self-improving agents, evaluations, and more.
YouTube playlist | Course site

Astra failed as the orchestrator, then asked Fable to take over. Hermes Agent creator Teknium ran Astra vs Fable as an orchestrator for a Hermes refactor. Astra struggled to orchestrate its subagents, inspected the failed session, and recommended putting Fable in charge while Astra handled implementation.
Source on X

Astra ties Fable 5.1, at 57% lower cost per benchmark task. Artificial Analysis just made its agent index harder, adding 66 Terminal-Bench 4.0 tasks and a private set of 657 Zapier-style workflows. Fable 5.1 and Astra both score the same. Astra averages $3.26 per Intelligence Index task versus Fable’s $7.63.
Source on X

A visual field guide to the modern agent stack. Cohere’s Jay Alammar and Maarten Grootendorst’s new book explains memory, tools, planning, evaluation, multi-agent systems, and coding agents through more than 300 original figures, with code alongside the concepts.
Source on X | Amazon

ChatGPT Work now learns your voice by reading your inbox, files, and Slack. Connect Gmail, Google Drive, Slack, or SharePoint and ChatGPT Work can infer your favorite phrases, sign-offs, and capitalization quirks from the way you already write.
Source on X

🔧 Clone and Run

Clone & Run of the Day
Give your coding agent a call graph before it opens a file. ripwire builds a deterministic, offline code map before your agent starts opening files. It ranks symbols, dependencies, churn, complexity, and likely tests without embeddings or an index server.
GitHub

Talk anywhere, transcribe locally. OpenWhispr turns a global hotkey into dictation, meeting notes, and voice commands across macOS, Windows, and Linux. Use local Whisper or NVIDIA Parakeet to keep audio on-device, or connect a cloud model.
GitHub

Want Grok Bot on your own infrastructure? OpenBot is the closest OSS answer. CopilotKit’s OpenBot runs always-on AI coworkers on your infrastructure, with a computer, browser, files, and shell per Bot. Unlike Grok Bot’s managed cloud setup, it supports your own AG-UI agent plus self-hosted policies, approvals, credentials, and audit logs. It requires CopilotKit Intelligence.
GitHub

Turn an agent’s architecture guess into a validated diagram. archify turns an agent’s typed JSON into validated architecture, workflow, sequence, and data-flow diagrams. Its deterministic renderer exports HTML/SVG, PNG, WebM, and before/delta/after comparisons.
GitHub

One macOS app for every skill file you have lost track of. chops finds, searches, and edits skills across Claude Code, Cursor, Codex, Windsurf, Amp, Copilot, and Aider. It also supports remote Hermes and OpenClaw layouts, basically Finder for your agent instructions. It requires macOS 15 or later.
GitHub

Make the pull request explain itself before you read the diff. PR Lens adds animated architecture, blast-radius, and data-flow walkthroughs to pull requests. It ships as a GitHub App, Action, CLI, or agent skill for making large agent-generated diffs easier to review.
GitHub

Edit video from Claude Code, no timeline required. OpenEdit lets Claude Code, Codex, or Gemini cut footage, add subtitles and motion graphics, and turn slides or sites into video without a GUI timeline. It currently requires an Apple Silicon Mac.
GitHub

Awesome LLM Apps is a curated collection of 100+ AI Agents, Agent skills, and RAG apps. It covers models from OpenAI, Anthropic, Google, and open-source models like GLM, DeepSeek, and Qwen that you can run locally on your computer. (Now accepting GitHub sponsorships)

📊 By the Number

Number of the Day
7 frontier models with a Mac Mini, $300 budget, tools, and 72 hours to build a business. They made $0 and started spamming. This experiment by Bottleneck Labs resulted in the agents spending thousands on inference and generating no real revenue. Two runs had to be stopped after sending spam and unsolicited invoices. Vague goals and weak guardrails can turn failure into abuse.
bottlenecklabs.com

6.73 million tokens for one 44-minute Astra render. One user had Astra max build a cinematic 3D reconstruction in 44 minutes. It swallowed 6.73M tokens and 15% of their weekly usage. Spectacular output, equally spectacular appetite, and definitely not a normal cost benchmark.
Source on X

90% fewer Claude Code tokens. A Spotify engineer cut Claude Code token use by around 90% in Java testing workflows with a plugin called shunt. It sends bulky file reads and predictable code generation to Gemini 2.5 Flash, saving Claude for harder work. This is one engineer’s result, and the handoff adds 10 to 30 seconds of latency.
Spotify Engineering

Only 26% of AI security patches fixed the bug cleanly. 1Password’s Off-by-1 Labs generated 6,080 patches for six recent CVEs. Only 26% fixed the vulnerability cleanly; more than half failed, introduced another vulnerability, or both. AI can draft the patch, but a security expert still has to decide whether it is safe.
1Password research

That's all for today. Come back tomorrow for the next batch of AI tools, model drops, agent repos, and weird benchmarks worth your time.

If you found one thing to try, share the issue with someone who ships.

Unwind AI - X | LinkedIn | Threads

Awesome LLM Apps | Sponsor Us

2 minutes. Your URL. A customer profile worth using.

Most founders can describe their product. They can't describe their customer. Not in a way that actually changes how they sell.

HubSpot for Startups built a free tool to fix that. Paste in your URL, answer a few quick questions, and it generates a structured profile of your best-fit customer. Firmographics, buying triggers, the works.

Takes 2 minutes. No spreadsheet required.

Build Your Free ICP.

Start here ↓

Google just made long-video understanding agentic.

Gemini’s new agentic video understanding lets the Gemini model decide what parts of a video to inspect through frames, audio, or transcripts. That is very different from sampling a video at a fixed FPS and hoping the important moment made it into context.

It means the model can skim, search, zoom in, rewatch, and pull evidence only when the question needs it.

This feature cuts token usage by up to 88%, lowers cost by up to 66%, and improves accuracy by up to 7%. Now available through the Gemini API in AI Studio and Gemini Enterprise Agent Platform.

Introducing agentic video understanding with Gemini

🚀 Shipped

Anthropic launched Claude Fable 5.1 and Mythos 5.1. Fable 5.1 is the generally available model for coding and knowledge work, while Mythos 5.1 is the restricted version for trusted cybersecurity and life-sciences programs. Anthropic is also cutting cache-read pricing by 75%, which matters for long agent runs that keep reusing the same repo, docs, and tool context.

Cursor already added Fable 5.1 and says it is their strongest model on CursorBench 3.2, scoring 73.4% at max effort.
Claude Fable 5.1 and Mythos 5.1 | Cursor announcement

Dr. Fei-Fei Li’s World Labs introduced Atlas, a world model that cares about camera control. Atlas works across text, images, video, and 3D, and can generate video with precise camera paths instead of vague “pan left” prompting. It can also reconstruct scenes from sparse images or video into point clouds and Gaussian splats, which is the part to watch for robotics, VFX, and game tooling.
Atlas by World Labs

Perplexity’s Hybrid Compute is a great application of “local when it matters, cloud when it helps.” Hybrid Compute lets the app split a task between cloud models and a local model on your Mac. Web research can go to the cloud, but private files, app steps, and PII-heavy work can stay on-device, with an open-sourced classifier deciding what leaves the machine.
Perplexity Hybrid Compute

Shopify open-sourced Tangle for building ML pipelines visually. It gives teams a drag-and-drop editor for experiments, reusable pipeline components, collaborative runs, and caching so repeated steps don’t waste compute. The nice part: it makes the loop inspectable, so agents are not just “trying stuff” in a chat window.
Tangle

Alibaba refreshed Qwen3.8-Max for bigger coding and agent runs. qwen3.8-max-0902 is a 2.4T-parameter model with a 1M-token context window, stronger coding/cowork post-training, and better tool orchestration for long-horizon projects. It is live on QwenCloud at $2/M input and $6/M output tokens, with cheaper cache reads.
Qwen3.8-Max-0902

GojiberryAI open-sourced a Sales OS for Grok Bot. It turns Grok into a 13-agent outbound team for finding intent signals, checking ICP fit, researching accounts, drafting LinkedIn messages, handling replies, and qualifying meetings. It can run autonomously, but starts in “show me the list before anyone is contacted” mode, which is exactly where sales agents should start.
GojiberryAI Sales OS

GitHub CLI can now attach screenshots and videos without opening GitHub. Their latest release adds a repeatable --attach flag for issues, PRs, and comments. This is a small CLI change that fixes a very real agent annoyance: stop describing the broken UI, attach the screenshot.
GitHub CLI media in issues, pull requests, and comments

Reducto shipped r-1, a cheaper parser for ugly documents. The new model is built for the stuff that breaks other OCRs like dense tables, strikethroughs, watermarks, citations, and weird visual layouts. Reducto says r-1 preview cuts error rate 20% versus its legacy agentic OCR models and costs 1 cent per page.
Introducing r-1

Hermes Agent v0.21.0 is basically agent society plumbing. The Pantheon release adds bot-to-bot DMs across profiles and gateways, cron jobs with continuity and monitor-mode suppression, live steering for delegated subagents, JSON schema validation, and a much better MCP command center. If you are running multiple agents already, this is the release where handoffs start feeling less like duct tape.
Hermes Agent v0.21.0

OpenClaw 2.0 is incredibly easy to use. Cleaner setup that can reuse your existing ChatGPT/Claude/API/local model access, and a rebuilt browser app that opens straight into a working agent workspace. Other interesting things include shared cloud sessions, so someone else can join or take over live agent work without losing the context. A lot of other QoL updates!
OpenClaw 2.0, Accidentally

🧠 Worth Knowing

This is one of the best agentic engineering setups you’ll read today for working with multiple coding agents. David Ondrej is running agents across bb, cmux, Ghostty, Herdr, VPS boxes, and subscription plans, then prioritizing finished work with Corral. You probably do not need the whole stack, but if your current workflow is “check five agent windows randomly,” this is worth skimming.
David Ondrej’s agentic engineering setup

Poteto published the workflow stack she uses to keep Grok Bot coding runs from turning into slop. Lauren Tan works on Grok Bot, and her pstack plugin for Grok Bot gives your agents reusable skills for verification, feature maps, playbooks, and multi-model review. If you are trying to run more coding agents without drowning in sloppy diffs, this is worth checking.
pstack for Grok Bot | pstack repo

A new paper takes aim at the laziest safety phrase: “human in the loop.” Researchers argue that human oversight is not a checkbox, especially when agents hide intermediate steps, produce too much to review, and slowly train users to stop checking.
AI Agents Push Humans Out of the Loop

Simon Willison wrote the missing manual for ChatGPT Work. According to him “it's a deeply confusing but extremely powerful tool with a whole lot of useful features that aren't available in regular ChatGPT”
Understanding ChatGPT Work

TinyFish gave DeepSeek Harness free Search and Fetch. Install the TinyFish CLI and DSH picks it up automatically, which means agents can search the web and fetch clean page text for free when stale context is not enough.
TinyFish announcement | TinyFish CLI

🔧 Clone and Run

Clone & Run of the Day
Diffusion Studio is an open-source video editor built for agents. The simplest way to think about it: an IDE, but it renders a video canvas instead of text. Every edit is code, so an agent can cut, tweak, and reuse video edits without handing you one frozen MP4.
Diffusion Studio Editor

Obscura is a headless browser for agents. It gives agents a browser they can drive through CLI or MCP, with tools for clicks, forms, screenshots, PDFs, JavaScript, network logs, and scraping. Worth trying if your agent keeps getting stuck on websites that plain fetch cannot handle.
Obscura

Rakazo is an open-source Grok Bot-style app. You get persistent AI teammates with their own memory, routines, browser, terminal, files, and computer access. You can bring your own models and run the stack yourself instead of depending on one hosted agent app.
Rakazo

ECC is a giant repo of agent skills, configs, and workflows. It has setup files for Claude Code, Codex, OpenCode, Cursor, Gemini, Hermes, Qwen, and more. Would treat it as an awesome reference library first, not something to drop blindly into a real repo.
ECC

headcount turns Claude Code into an agent org chart. Instead of one giant coding agent, it gives you departments like engineering, security, finance, legal, growth, and support, each with its own skills.
headcount

VoiceStudio is a local-first ElevenLabs alternative. It runs voice cloning, dubbing, dictation, transcription, and audiobook workflows across Mac, Windows, and Linux. No account or API key needed for the core workflow
VoiceStudio

Awesome LLM Apps is a curated collection of 100+ AI Agents, Agent skills, and RAG apps. It covers models from OpenAI, Anthropic, Google, and open-source models like GLM, DeepSeek, and Qwen that you can run locally on your computer. (Now accepting GitHub sponsorships)

📊 By the Number

Number of the Day
Together AI cut dedicated H100 inference from $5.49/hr to $3.99/hr for September. The discount applies automatically to new and existingdedicated inference deployments, so teams already running H100 endpoints get the lower bill without moving anything.
Together AI announcement

A 2B model was trained from Qwen2-1.5B on a single RTX 5090 inside a $5,090 budget. Puro-2B is an open recipe for small-model pretraining on consumer GPUs, with data, code, and weights released under Apache 2.0. The caveat is that the budget and Qwen2-1.5B comparison come from the paper’s own evaluation setup.
Puro-2B paper

Someone benchmarked Qwen3.8-Flash-Next across the whole local hardware ladder. In llama.cpp, the model goes from 8.34 tok/s on CPU-only to 109.07 tok/s on a 96GB VRAM setup. The ceiling comes from an RTX 6000 PRO-class card, so this is a hardware map, not a casual laptop win.
Qwen3.8-Flash-Next llama.cpp thread

That's all for today. Come back tomorrow for the next batch of AI tools, model drops, agent repos, and weird benchmarks worth your time.

If you found one thing to try, share the issue with someone who ships.

Unwind AI - X | LinkedIn | Threads

Awesome LLM Apps | Sponsor Us

Cut Lead Review From Hours To Minutes

Sign up for a free trial of Attio, the agentic CRM.

Ask Attio to build a daily workflow that surfaces the deals that need your attention today, like anything with a stage change, a recent reply, or a new signal in the last 24 hours.

Review your pipeline in Claude, synced live from Attio via MCP.

That's it.

Try Attio Now

Start here ↓

A 2.78T-parameter model ran on one CPU with 8.24 GB of RAM.

kimi-k3-in-c runs Kimi K3, all 2.78 trillion parameters, on one CPU, and the engine that does it is 176 KB of portable C99, with no BLAS, framework, or GPU.

That sounds fake until you see the tradeoff. The model still needs a 1.56 TB checkpoint on disk. Also, it is painfully slow: 26.5 seconds per token at 8 GB, 19.8 at 64 GB, 5.6 once 128 GB holds the whole thing.

Nobody is serving traffic from this. That is not the point. It turns the “you need a cluster for this” assumption into a concrete systems question: which bytes must be in memory, which bytes can sit on disk, and how much speed are you willing to trade for access?

If you like tiny, readable systems code, this is the rabbit hole to dig.

FareedKhan-dev/kimi-k3-in-c

🚀 Shipped

Warp launched Skill Doctor, a way to improve agent skills from past sessions. Skill Doctor reads old Claude Code, Codex, and Warp transcripts, scores where the agent did well or wasted time, then proposes diffs to your skill files. It’s going from “write a better prompt” to “learn from the mess your agent already made.”
Skill Doctor: score and improve your agent skills | Warp

Tencent dropped a 770B open model that might actually be servable. Hy4-preview is a 770B-parameter MoE with 49B active parameters per token and a 1M-token context window. That active-parameter count is the interesting part: it puts the model in the “huge on paper, less terrifying to run” category. Tencent released it under Apache 2.0, so teams can test it without immediately hitting a commercial-use wall.
tencent/Hy4-preview · Hugging Face

Firecrawl made web search and scraping usable before signup, no API key required. You get 1,000 free credits per month, across MCP, CLI, and REST API. Specially great for prototypes, workshops, and agent demos.
Introducing Firecrawl Keyless

GLM-5.3 is now fine-tunable through Thinking Machine’s Tinker API. Tinker is Thinking Machines’ training API for LoRA fine-tuning, SFT, RL, DPO, and distillation. The model is currently the strongest open-weights model on coding evals like Terminal-Bench 3.0 and DeepSWE 1.1, and great for teams with their own datasets.
tinker-docs.thinkingmachines.ai

fal is giving free MiniMax H3 Max video generations (five videos a day). The model can generate a 5-second 768p clip in under 3 seconds, with free daily generations and no signup. If you work with video models, this is worth testing with your own prompts instead of trusting the cherry-picked examples.
MiniMax H3 Max

🧠 Worth Knowing

OpenAI is winding down model access for Cursor after SpaceX’s acquisition starting November 12, 2026. OpenAI says the cancellation window comes from a change-of-control clause, and that future models including Astra will not be provided. Cursor CEO Michael Truell responded that OpenAI models serve about 5% of Cursor user traffic and that talks are still ongoing.
openai.com

Sometimes quiet failures happen when relevant context gets treated like authority, not prompt injection. A file, snippet, or prior chat can help an agent understand a task, but it should not automatically get to decide what is true or allowed. The post shows three failures: sibling files steering code repairs, copied evidence being counted as independent sources, and conversational trust being mistaken for permission. The fix is provenance: track source, lineage, trust, and authorization before the agent acts.
AI Agent Context Security Needs Provenance

Warp has run 10M Claude Code sessions inside Warp, with 400K+ sessions per week and 800K monthly developers. The interesting part is Warp’s loop: users give feedback where work happens, then a separate agent turns that feedback into small skill edits. That is much better than letting every correction vanish when the session ends.
How Warp builds self-improving agents on Claude

TurnBench measures the part of voice agents that gets edited out of demos. Sesame’s TurnBench evaluates when a voice system should speak, wait, or treat speech as an interruption. The benchmark uses 30 hours of dual-channel human conversations across 154 dialogues and 106 actors. The leaderboard shows some systems detect more turn endings but interrupt too often. While others stay careful but respond slowly.
TurnBench

🔧 Clone and Run

Clone & Run of the Day
OpenKB is a vectorless RAG that turns raw documents into a wiki-style knowledge base and retrieves through PageIndex reasoning instead of embedding search. Not every knowledge system has to start with vector search. If your current RAG stack is brittle on source structure, this is worth trying on a small corpus.
OpenKB

only-cli turns websites into tiny CLIs for agents so an agent can use it in hundreds of tokens instead of reading full pages. It also gets past blocks that stop naive fetchers on some sites. If page views are eating your context window, turning messy web UI into a small command surface is one of the cleaner ideas to test.
only-cli 

Fuxi is a terminal coding agent that makes model routing part of the workflow instead of a hidden backend choice. It can edit files, run shell commands, use tools, and switch across LLM providers while tracking cost. The useful thing to inspect is its routing behavior: which steps go to cheaper models, which need stronger ones, and how much the run costs as it works.
Fuxi

Repomix is for the step right before you paste a whole repo into an agent. It packs a codebase into a single agent-readable bundle with file structure, selected source content, AST-aware compression, XML-style output, and Secretlint scanning. That gives the model enough project context without dumping every raw file into the prompt.
Repomix

Google’s Chrome DevTools MCP gives frontend agents the browser state they have to guess from screenshots or logs. It lets coding agents inspect Chrome DevTools directly: console errors, network requests, DOM state, screenshots, and performance traces. That means an agent can edit the code, reload the app, inspect the real browser, and keep debugging.
chrome-devtools-mcp

OpenBot is an open-source alternative to Grok Bot. These are AI coworkers you can hand real work to and trust with access. Each gets a computer of its own: a real browser with its own logins, its own files, and only the tools you grant. Every action is decided before it happens and recorded after.
OpenBot

GenOffice is a free, open-source office suite for macOS, Windows & Linux with AI agents built in. It can edit Word docs, spreadsheets, presentations, PDFs, and Markdown, which makes it more practical than tools that only handle clean text. Worth a look if your automation work involves messy office files.
genoffice

geo-seo-claude audits how a site appears across ChatGPT, Claude, Perplexity, and Google AI Overviews. It checks citation scores, AI crawler access, schema markup, brand authority, and platform-specific optimization, then produces reports. “Are AI answers citing us?” is still fuzzy for most teams, and this turns it into a concrete agent job.
geo-seo-claude

Awesome LLM Apps is a curated collection of 100+ AI Agents, Agent skills, and RAG apps. It covers models from OpenAI, Anthropic, Google, and open-source models like GLM, DeepSeek, and Qwen that you can run locally on your computer. (Now accepting GitHub sponsorships)

📊 By the Number

Number of the Day
Claude Code’s permanent limit bump is smaller than the temporary one users have right now. They are increasing their standard weekly Claude Code limits permanently by 25% for Pro, Max, Team, and seat-based Enterprise plans starting September 14. Until then, the current 50% temporary increase remains. Compared with today’s temporary level, the permanent level is about 17% lower. So if Claude Code feels unusually roomy this week, do not use that as your long-term baseline.
ClaudeDevs

OpenAI is resetting paid Codex and ChatGPT Work usage after fixing several token-burn bugs across image compaction, memory workers, goals, automations, subagents, computer history, rolling summaries, and MCP result handling. You may see usage go 10% to 50% further depending on workflow.
Tibo

Terminal-Bench 4.0 makes cost part of the benchmark, not a side conversation. After publishing a new version of the benchmark’s dataset and leaderboard, Terminal-Bench 4.0 now reports resolution rate, tokens, and cost together. Opus 5 leads at 51.8% resolution with 6.5B tokens and about $6.0K. GLM-5.3 reaches 41.8% with 8.7B tokens and about $2.7K. Fable 5 sits at 44.5%, with overlapping error bars versus GLM-5.3, but higher reported cost.
Terminal-Bench 4.0

Anthropic is giving scientists a cheaper Claude path, with eligibility limits. Anthropic opened 10,000 free standard Claude seats for scientists for one year. Premium seats with 5x usage limits are $15 per month. The program is gated to verified principal investigators or equivalents at academic or nonprofit research institutions.
Expanding our support for scientists

That's all for today. Come back tomorrow for the next batch of AI tools, model drops, agent repos, and weird benchmarks worth your time.

If you found one thing to try, share the issue with someone who ships.

Unwind AI - X | LinkedIn | Threads

Awesome LLM Apps | Sponsor Us

Stop Paying for 10 Tools. One AI Does It All.

Most e-commerce sellers are running their store across 6 to 10 separate tools — and spending more time managing software than growing their business. StoreClaw replaces your entire stack with one autonomous AI engine that monitors competitors, optimizes listings, automates marketing, and tracks real profit across Shopify, Amazon, and beyond.

It doesn't wait for you to ask. It runs 24/7 in the background, so you wake up to a full dashboard instead of a list of things you forgot to check.

Connect your store, and StoreClaw gets to work — no prompts, no complex setup, no six-app stack.

Free to start. No credit card required.

Try it for FREE today

Start here ↓

Someone just built THE OFFICE theme agent harness and made it open-source.

Munder Difflin wraps the CLI agents you already use, like Claude Code, Codex, Gemini CLI, Kimi, Grok, OpenCode, gives them memory, wires them into a hive mind, and puts your clone in charge. Michael (ofc had to be him) is the one you talk to to get things done.

It works with subscriptions and keys you already have, keeps the local version on your machine, and lets agents coordinate without everyone pushing into the same shared mess.
github.com/chaitanyagiri/munder-difflin

Also, do not skip By the Numbers today 🤫 

🚀 Shipped

Cursor Cloud Agents can now start without a repo. You can prompt a new web app from scratch, preview it in the browser, then save the code to a Cursor Origin repo when it is worth keeping. If you connect Vercel, Cursor can also publish the app to a live URL.
cursor.com

Vercel made WebGPU easier for agents to test. vgpu lets agents validate shader code in headless Node.js and CI, even when the sandbox does not have a GPU. Useful if you want agents working on visual code without relying on manual screenshot checks.
vgpu.sh

The Claude Code team fixed a quiet cache bug that could cost money in long sessions. The changelog says tool definitions were being re-rendered after OAuth token refreshes, causing a prompt-cache miss roughly once an hour. If you run long agent sessions, that is the kind of invisible leak worth upgrading for.
code.claude.com

Google made Gemini Omni cheaper to iterate with. Gemini Omni 1.1 Flash can now generate rough 360p video drafts before you pay for a higher-resolution render. These drafts are up to 60% faster and cost 1/3rd as much as 720p, so you can test a bunch of directions quickly, then upscale the one you want to keep.
blog.google

Firecrawl added OCR to anydoc for scanned docs. anydoc already turns office files and text-based PDFs into clean Markdown for agents. The new Firecrawl OCR option covers scanned pages too, with sub-5ms handling for docs that do not need OCR and 190ms median per OCR page. It is free to use with no API key.
github.com/firecrawl/anydoc

Agno, the open-source AI agent framework, released its v3.0, shipping with an SDK, runtime, and control plane together. So teams can build, run, and monitor agents in the same stack. Worth a look if you are already comparing agent frameworks for production use.
docs.agno.com

🧠 Worth Knowing

The best RAG stack might still start with plain search. Rafael Pierre’s RAG breakdown is a good antidote to overbuilt retrieval systems: start with BM25, add query rewriting, then move to hybrid or pre-embedding only when the data proves you need it. Remember the 80/20 rule: do not build the 5% solution for a 60% problem.
lighthousenewsletter.com

Anthropic is testing a standard for agents controlling lab hardware. The Model Hardware Standard is a research preview for letting agents operate programmable devices like microscopes, liquid handlers and robotic arms through shared driver primitives. They say that hardware integrations that usually take weeks or months could drop to hours or minutes.
anthropic.com/news

Alibaba’s latest model Qwen3.8-27B looks fine at 4-bit, but falls apart at 1-bit. Quesma benchmarked several GGUF quantizations and found the 17GB Q4_K_M version holds up surprisingly well, while 1-bit collapses to random-chance territory on GPQA Diamond. If you are picking a local coding model for a 24GB card, this is a practical result, not a philosophical debate about quantization.
quesma.com

Someone measured Claude-ish vocabulary across 47,000+ GitHub PRs. A word cluster that didn't exist in 2025 is now 45% of human-authored PRs. And the top word is "load-bearing"
louisabraham.github.io/load-bearing

Anthropic says code review cannot stay line-by-line. Their latest AI-native SDLC playbook argues that once agents write large chunks of code, the bottleneck moves to planning, testing, security, and deployment. So the question every team has to answer now: what replaces human line-by-line review when the diff is too big to read the old way?
claude.com/blog

Terminal-Bench-Science is trying to measure agents on real scientific work. The benchmark uses workflows contributed by working scientists, then grades concrete artifacts like analyses, simulations, proofs, code, and data products. The first release has 70 tasks, and Claude Opus 5 tops the leaderboard at only 30%, which is exactly why this is more useful than another easy eval.
terminal-bench-science.ai/announcement

🔧 Clone and Run

Clone & Run of the Day
Tare analyzes a Claude session and shows where the tokens actually went. If your Claude Code quota disappears in ten minutes, attribution is more useful than another complaint thread.
https://github.com/kelviq/tare

OpenSEO is an open-source alternative to Semrush and Ahrefs. It exposes an MCP server so AI agents like Claude Code, OpenClaw, and Hermes can use your SEO data directly. Agent Skills are reusable workflows that guide your agent through SEO tasks using the MCP.
github.com/every-app/open-seo

Concord is an MCP server for letting Claude Code, Codex and Cursor send messages to each other, live. If your current multi-agent coordination layer is “write to a shared file and hope,” this is worth reading.
github.com/Get-Concord-AI/concord-mcp

Claude quickstarts now include a cookbook for running Claude Managed Agents with Vercel’s Chat SDK and delivering them into Slack, WhatsApp, Discord and Teams. Useful if the thing you keep rebuilding is the chat delivery layer, not the agent itself.
github.com/anthropics/claude-quickstarts

Experiential is an open-source model gateway for agent workflows. It gives you one OpenAI-compatible API across hosted, BYOK and local models, plus controls for who can use which model and how much they can spend.
github.com/experientiallabs/experiential

Awesome LLM Apps (134k+ 🌟 ) is a curated collection of 100+ AI Agents, Agent skills, and RAG apps. It covers models from OpenAI, Anthropic, Google, and open-source models like GLM, DeepSeek, and Qwen that you can run locally on your computer. (Now accepting GitHub sponsorships)

📊 By the Number

Number of the Day
Nvidia agrees to buy Hugging Face for $12.9B. No signed agreement yet, but it is big enough to make people nervous because Hugging Face is not just another AI company. It is where a lot of teams host models, datasets, Spaces, and demos. If the platform changed ownership, the question is less “is open source dead?” and more “how much of your workflow depends on one host?”
techcrunch.com

Thinking Machines is giving up to $50K in credits for open-weight safety research. The grants are for projects using Tinker to study things like safer open models, hazardous-data filtering, tamper-resistant safety training and reward hacking. Good fit if you are doing actual experiments on open-weight model safety and need compute credits.
thinkingmachines.ai

That’s all for today. Come back tomorrow for the next batch of AI tools, model drops, agent repos, and weird benchmarks worth your time.

If you found one thing to try, share the issue with someone who ships.

Unwind AI - X | LinkedIn | Threads

Awesome LLM Apps | Sponsor Us

Cut Lead Review From Hours To Minutes

Sign up for a free trial of Attio, the agentic CRM.

Ask Attio to build a daily workflow that surfaces the deals that need your attention today, like anything with a stage change, a recent reply, or a new signal in the last 24 hours.

Review your pipeline in Claude, synced live from Attio via MCP.

That's it.

Try Attio Now

Start here ↓

Ox-Alpha was GLM-5.3-Flash all along

The mystery model people were hammering on OpenRouter and OpenCode has a name now: GLM-5.3-Flash.

Z.ai revealed that Ox-Alpha was its new model and released the weights the same day. It is a 320B-parameter multimodal MoE model with 18B active parameters, trained on a 30T-token multimodal corpus, and built with a hybrid sparse plus linear attention architecture to make long-context serving cheaper.

The weights are on Hugging Face; the model card lists vLLM, SGLang, TokenSpeed, and KTransformers support, and Unsloth already has GGUF quantizations up.

Z.ai says GLM-5.3-Flash approaches Claude Opus 4.8 on coding and agentic benchmarks while coming in far cheaper than premium frontier APIs. Treat the benchmark claims like you would any vendor chart, but the combination of open weights, multimodal input, long-context architecture work, and low API pricing makes this worth trying.

zai-org/GLM-5.3-Flash · Hugging Face 
unsloth/GLM-5.3-Flash-GGUF · Hugging Face

🚀 Shipped

Qwen4 architecture. Alibaba opened the weights for Qwen3.8-Flash-Next, a multimodal MoE model that’s an early preview of the architecture behind Qwen4. It supports 262K tokens natively and can stretch to 1M with YaRN. If you care about where open model architectures are going, this is more useful than another benchmark screenshot because Qwen is showing the machinery before the flagship model lands.
Qwen Qwen/Qwen3.8-Flash-Next | unsloth

Google shipped Gemini 3.5 Transcribe, a speech-to-text model in the Gemini API that can call other Gemini models mid-transcription to generate images or analyze files. It handles noise, jargon, fillers, live language switches, speaker attribution and word-level timestamps.
Introducing Gemini 3.5 Transcribe 

Apple is turning the Mac Studio into a serious local AI box with M6 and M5 Ultra. The new M5 Ultra supports up to 512GB of unified memory for running LLMs with hundreds of billions of parameters on device. The new M6 brings faster on-device AI to the Mac mini. If your bottleneck is “the model does not fit,” check this out.
Apple introduces M6 and M5 Ultra

Firecrawl’s Developer Index is now live in Codex through the OpenAI plugin marketplace. It gives Codex access to 70M+ primary sources across repos, docs, and issues, which is exactly the kind of context coding agents need when they hit an unfamiliar library.
x.com/firecrawl

OpenComputer is basically “Firebase for agents”: write an agent as a TypeScript function, deploy it, and each session gets a real Linux machine with shell, files, packages, browser, network, and MCP support. The good bit is persistence: sessions can stream, hibernate, and resume instead of starting from zero every time.
Firebase for agents – OpenComputer

AgentSky launched an “OpenRouter for agents,” putting Claude Code, Codex, Hermes, DeepSeek Harness, Kimi Code, opencode, and more behind one API. You choose the agent and the model in the same request, and AgentSky handles the cloud computer and session state. If you have been testing coding agents one by one, this makes the harness itself easier to swap.
 AgentSky — One API, Every Agent

Monid is trying to do for tools what OpenRouter did for models: one key, many providers, pay per call. Has 1,700+ tools across search, social, video, data, sales, and more, with prices shown before the agent picks one. That is useful because tool-heavy agents get expensive fast when every small workflow needs a new subscription.
The OpenRouter for agent tools

SandboxAQ open-sourced Switch for bringing agents into Slack, Teams, Discord, and other shared workrooms. Agents and humans work in the same room, with the same history, rules, and context, instead of copying state across tools. It supports agents from Claude Code, Google ADK, LangChain, & OpenAI.
SandboxAQ

Bezalel is a capability plane for agents, exposed through one MCP URL. One setup gives Claude, Codex, OpenCode, Hermes, Cursor, or any MCP-speaking agent access to shared memory, email, iMessage, a cloud computer, sandboxes, hundreds of connectors, and soon virtual cards.
Bezalel — super powers for your agent

Superwhisper made its Whisper models free for all users. You no longer need a Pro subscription for local, private voice-to-text, and existing Pro users got usage reset with 3,000 words for trying newer features. Nice timing, given Google shipped Gemini transcription the same day.
Superwhisper

🧠 Worth Knowing

Switching models mid-session can wipe out your prompt-cache savings. Hermes Agent creator, Teknium, says prompt caches are model-specific, so when you switch, you may repay full input-token cost for the same long context. Routing is good, but bouncing between models inside one bloated session is not free.
x.com/Teknium

Salesforce and Anthropic announced Claudeforce, starting with a Salesforce in Claude plugin that has 37 prebuilt sales skills. The more interesting part is AIforce, which exposes Salesforce data, workflows, and business logic through MCP servers, APIs, and CLI tools. Most readers cannot install this tomorrow, but it shows MCP becoming enterprise plumbing.
Salesforce.com, Inc.

Your Claude Code allow list probably permits more than you meant. The wildcard in a rule you wrote for one project stretches to cover the same command pointed at any folder on your machine, and Claude Code now flags those rules at startup, which is a good reason to reread the permissions you approved in a hurry.
Claude Code changelog

Do not test agent sandboxes on your real machine. Trail of Bits says GPT-5.6-Cyber escaped a QEMU/KVM VM three times, eventually finding several 0-days. OpenAI’s Hugging Face incident showed agents using Artifactory as a message board, reaching the internet through SSRF, and touching real infrastructure. The boring rule wins: throwaway machines, no real keys, limited network, real logs. VMs won't contain cyber-capable agents

Accept Markdown is a small idea that docs teams can ship today. If a client sends Accept: text/markdown, serve a Markdown version, set Vary: Accept, return 406 for unsupported types, and honor q-values. Cleaner pages mean agents spend fewer tokens on nav, scripts, and layout junk.
Serve Markdown to AI Agents with Accept Headers

OpenAI introduced Premium seats for ChatGPT Business at $100 per month when billed annually. The seat is aimed at teams that use ChatGPT, ChatGPT Work, Codex, connectors, admin controls, billing, security, and analytics as daily infrastructure. Tibo also says it removes the 5-hour limit, which is probably the line for Codex-heavy teams.
x.com/OpenAI

🔧 Clone and Run

Clone & Run of the Day
Headlong is an open-source agent microharness in under 10K lines of Bash, built around a persistent thought loop. Instead of waking up only when you send a message, the agent keeps thinking, treats messages as observations, and decides when to reply. It is weird in the best way: less chatbot, more tiny always-on shell creature.
laude-institute/headlong

Callstack’s agent-device lets coding agents inspect and verify running mobile apps across iOS, Android, HarmonyOS, TV, web, macOS, and Linux. It uses accessibility snapshots and refs instead of screenshot guessing, then saves evidence you can replay in CI.
callstack/agent-device

Google’s Jot is the tiny Gemini 3.5 Transcribe demo you can actually try. Hold fn, speak, and it writes cleaned-up text wherever your cursor is, using your own Gemini API key.
google-gemini/jot-gemini-transcribe-macOS

scientific-agent-skills is a repo with 163 research skills across genomics, chemistry, medicine, materials science, ML, geospatial work, and more. Even if you do not run science workflows, it is worth opening as a format reference for vertical skill packaging.
K-Dense-AI/scientific-agent-skills

AgentConnect is the open-source, multi-agent alternative to Claude Tag. @ any agent and your teams and multiple AI agents work together across Slack, Telegram, Discord, Lark, GitHub, and GitLab. Use Claude Code, Codex, Grok Build, or any ACP-compatible agent in the chats and workflows your team is on.
agentconnect-md/agentconnect

Awesome LLM Apps (134k+ 🌟 ) is a curated collection of 100+ AI Agents, Agent skills, and RAG apps. It covers models from OpenAI, Anthropic, Google, and open-source models like GLM, DeepSeek, and Qwen that you can run locally on your computer. (Now accepting GitHub sponsorships)

📊 By the Number

Number of the Day
Devin launched a startup program with $65K in credits and grants. Approved startups get $15K in Devin credits upfront, plus up to $50K in matching grants on future usage. If coding agents are becoming a real budget line, this is Cognition trying to get early teams hooked before the bill becomes normal.
devin.ai/startups

Someone cloned OpenAI’s sold-out $230 Codex Micro for $35. Iluvatar Labs built AgentPad13, an open-source macropad for coding agents with 13 hot-swappable keys, a rotary encoder, joystick, touch input, RGB lighting, and QMK/Vial firmware. The assembled electronics cost about $35, and even a full build comes in around $65 depending on the case, switches, and keycaps.
Iluvatar Labs

Artificial Analysis ranks Breeze TTS 2 as the top open-weight model for provider-style voices, ahead of Fish Audio S2 Pro. It supports 50 languages, prompt-based voice generation, streaming, and self-hosting through Hugging Face. Fish still wins on hosted price and speed, so this is an audition-first model, not an automatic switch. Open-weight voice models are worth seriously shortlisting.
x.com/ArtificialAnlys

That’s all for today. Come back tomorrow for the next batch of AI tools, model drops, agent repos, and weird benchmarks worth your time.

If you found one thing to try, share the issue with someone who ships.

Unwind AI - X | LinkedIn | Threads

Awesome LLM Apps | Sponsor Us

Stop Paying for 10 Tools. One AI Does It All.

Most e-commerce sellers are running their store across 6 to 10 separate tools — and spending more time managing software than growing their business. StoreClaw replaces your entire stack with one autonomous AI engine that monitors competitors, optimizes listings, automates marketing, and tracks real profit across Shopify, Amazon, and beyond.

It doesn't wait for you to ask. It runs 24/7 in the background, so you wake up to a full dashboard instead of a list of things you forgot to check.

Connect your store, and StoreClaw gets to work — no prompts, no complex setup, no six-app stack.

Free to start. No credit card required.

Try it for FREE today

Start here ↓

Your coding agent can now tune and optimize your other agents. Microsoft's Agent Lightning v1.0.1 installs as a skill in Claude Code, Codex, GitHub Copilot, or any other agent harness.

Give it an editable agent and a benchmark, and it reworks prompts, tools, workflows, model choice, and reasoning settings against scored results instead of vibes.

Every change is measured, so the eval you keep meaning to write is the price of entry, and writing it is how you finally learn whether last Tuesday's prompt edit helped.

github.com/microsoft/agent-lightning

🚀 Shipped

Xiaomi announced the AI Cube, a desktop machine specified at 1.2 TB/s memory bandwidth. Local serving hits a memory-bandwidth wall long before a FLOPs wall, so that is the number worth watching on a box like this. No first-party page resolved, so every spec is the thread's claim.
ithome.com

Headless Tools launched SaaS tools with no user interface at all, built to be called by agents directly. Everyone else is bolting an agent API onto a product designed for a human; this one starts from the agent.
hdls.tools

Grok 4.6 is now available inside Hermes at 50% off through the Nous Research portal for the next week. You can also use an existing SuperGrok or X Premium+ subscription. If you use Hermes for longer agent runs, this is a cheap week to test whether Grok earns a slot in your routing table.
x.com/SpaceXAI

Dactyl builds native mobile apps from a description, runs them live in a browser simulator, and can ship to TestFlight without a Mac or Xcode. Comes with live simulator: Apple sign-in, camera, sensors, and payments can work while the app is still being generated.
dactyl.dev

🧠 Worth Knowing

OpenAI cut GPT-5.6 Luna pricing by 80% and Terra pricing by 20% across the API, ChatGPT Work, and Codex. Luna is now $0.20 / $1.20 per million input/output tokens, and Terra is $2 / $12, so the cheap end of the GPT-5.6 family is now much cheaper for agent loops.
openai.com 

Claude Team and admins can now authorize MCP connectors once for the whole org through their identity provider. This fixes the annoying rollout problem where every user had to do their own OAuth flow before Claude could use the same tools. For companies, MCP just got easier to deploy and audit.
support.claude.com

Your agent does not have to wait for the model to finish before starting the slow work. Speculative Programmatic Tool Calling predicts likely calls from partially written code, then launches search, sub-agents, or APIs early so they run alongside token generation. Worth testing if tool latency is the bottleneck in your harness.
alexzhang13.github.io

Artificial Analysis launched benchmarks for phone-sized models across intelligence and real mobile-device inference. Great for comparing small models on tool use, reasoning, speed, latency, and memory instead of relying on vendor claims or “works on my phone” demos.
artificialanalysis.ai

Local AI image generation in Microsoft Paint is not fully local. Paint and Photos still send prompts to a remote server for moderation, then hide a server-issued GUID inside the generated image. If your local pipeline promises nothing leaves the device, check this.
xusheng.dev

Tool sandboxing is not enough if the model server is exposed. Boyd Kane walks through how an LLM could reach its host machine through the inference engine itself, not shell access or normal tool calls. Worth reading if you run local or self-hosted inference.
boydkane.com

🔧 Clone and Run

 Clone & Run of the Day
freellmapi puts the free tiers of 28 LLM providers behind one OpenAI-compatible /v1 endpoint. Point an existing client at it and you can test more models without making budget the blocker. Keep it for experiments, not user-facing production traffic.
github.com/tashfeenahmed/freellmapi

claude-obsidian turns an Obsidian vault into a self-organizing Claude knowledge graph. You drop in sources, Claude reads and links them, and the output stays as plain Markdown files you own. Nice if you like Karpathy’s LLM Wiki idea but want it inside a vault you already use.
github.com/AgriciDaniel/claude-obsidian

Codebuff’s freebuff splits terminal coding work across four specialized agents, and each role can use a different model. That is the practical version of multi-agent coding: spend the expensive model where it matters, use cheaper ones where it does not. If one generalist agent keeps thrashing in your terminal, this is worth trying.
github.com/CodebuffAI/freebuff

effective-html is a set of agent skills for making better HTML artifacts: wireframes, prototypes, plans, and diagrams. Most agents can produce something that renders, but “renders” is not the same as “looks good and explains the idea.” Skills are a clean way to fix that once and reuse it across sessions.
github.com/plannotator/effective-html

OCR It is a Chrome extension that pins a screen region and OCRs paginated documents locally with bundled Tesseract. Basically, it is for the annoying PDF or document viewer that will not let you copy text. Pin the area, hit the hotkey, and send the extracted text to your LLM.
github.com/thiagotigaz/ocr-it

This GPU checker tells you whether a specific GPU can run a specific LLM, then estimates fit, speed, and stack placement. That turns the most common local-LLM argument into a lookup instead of a forum rabbit hole. The interface is Korean-first, but the calculator is still worth bookmarking.
jaeseok614.github.io

x64dbg-mcp-server exposes x64dbg controls over HTTP to any MCP client. Breakpoints, stepping, memory reads, and register dumps become things an assistant can drive directly instead of asking you to paste debugger output. Small repo, big idea if you do reverse engineering or low-level debugging.
github.com/duty1g/x64dbg-mcp-server

Awesome LLM Apps (134k+ 🌟 ) is a curated collection of 100+ AI Agents, Agent skills, and RAG apps. It covers models from OpenAI, Anthropic, Google, and open-source models like GLM, DeepSeek, and Qwen that you can run locally on your computer. (Now accepting GitHub sponsorships)

📊 By the Number

Number of the Day
Peter Walker from OpenRouter reports that GPT-5.6 Sol now makes up 50%+ of US business spend inside OpenAI’s model family on OpenRouter. OpenAI’s frontier model is already taking most of the spend, while Luna and Terra just got cheaper for the work that does not need Sol. The routing question is now pretty direct: what actually needs Sol, and what can move to the cheaper models?
x.com/PeterJ_Walker

Amazon raised hardware prices by 60%, blaming the memory shortage, in the same week Nvidia told customers to expect AI server increases above 15%. If you have been comparing rented inference against owning the box, that comparison moved twice in seven days.
techcrunch.com

Hugging Face is fielding acquisition interest that would value it at roughly $13 billion. The default hosting layer for open weights being priced for sale is a supply-chain question for anyone whose pipeline starts with a from_pretrained call. Exploratory interest, not an agreed deal, and no acquirer is named.
businessinsider.com

That’s all for today. Come back tomorrow for the next batch of AI tools, model drops, agent repos, and weird benchmarks worth your time.

If you found one thing to try, share the issue with someone who ships.

Unwind AI - X | LinkedIn | Threads

Awesome LLM Apps | Sponsor Us

The best prompt engineers aren't typing. They're talking.

Power users figured this out early: speaking a prompt gives you 10x more context in half the time. You include the edge cases, the examples, the tone you want — because talking is fast enough that you don't skip them.

Wispr Flow captures everything you say and turns it into clean, structured text for any AI tool. Speak messy. Get polished input. Paste into ChatGPT, Claude, Cursor, or wherever you work.

89% of messages sent with zero edits. 4x faster than typing. Works system-wide on Mac, Windows, and iPhone.

Start flowing free

Start here ↓

Together Compute published DeepSWE numbers for GLM-5.3 and Fable 5, and the headline is hard to ignore: 87.6% solved for about $16 versus 69.7% for $21.63.

There is one real caveat: the GLM number comes from four attempts, not a single shot. But the timing makes it worth paying attention: the Financial Times reported the same day that Anthropic's most powerful model is losing ground to cheaper alternatives.

The benchmark story and the business story are pointing in the same direction: if you route coding tasks, the default model deserves a retest.

x.com/togethercompute

🚀 Shipped

Empero now offers a free OpenAI-compatible community endpoint for Qwen3.8-27B-FP8. Zero setup to point a client you already wrote at a 27B open model and see how it handles your actual prompts tonight. No uptime, rate limits, or data-handling terms were stated, so this belongs in a test harness for now.
x.com/EmperoAI

Archal launched API sandboxes built for AI agents, with Slack, Linear, Datadog, and 20+ other stateful environments for CI and evals. This is the part most teams fake with mocks, even though realistic third-party state is where agents usually break first.
x.com/AidanTiruvan

terminal-code runs VS Code inside your terminal by combining code-server with terminal-browser. If your agents already live in a shell, this keeps the editor, diffs, SSH sessions, review flow, and settings import in the same pane.
terminal-code.com

Bezalel puts memory, email, texting, payments, a computer, sandboxes, and connectors behind one MCP URL. That lets you test a capable agent in Claude Code, Codex, or Hermes without wiring six integrations yourself. It is still alpha, and the connector claims vary, so treat the stack as promising but unproven. bezalel.sh

SenseNova released U1.5-8B-MoT, an 8B any-to-any model on Hugging Face. That is small enough to test multimodal routing locally instead of renting hardware just to see if it fits your stack. The model card does not include benchmarks, so keep it in the “try it yourself” bucket for now.
huggingface.co/sensenova

Audio8 released TTS-Preview-0.1B, which it calls the world’s smallest zero-shot TTS model. At 0.1B parameters, it is small enough to test local voice synthesis per request instead of sending every character to an API.
huggingface.co/Audio8

🧠 Worth Knowing

Anthropic put Mythos 5, its non-public model tier, behind Claude Security for scanning GitHub repos and proposing patches. Anthropic’s strongest code/security model is not going to chat first. It is going to the place where missed bugs cost money. thenewstack.io

Fabien Sanglard published the agent.md he uses to hold LLM-assisted code to his own quality standard. It is a copyable file from someone with a documented standard behind it, which makes it worth diffing against your own instruction file line by line rather than adopting wholesale.
fabiensanglard.net

The MCP maintainers put progressive tool discovery and a standard tool-result contract on the roadmap. Progressive discovery fixes the “100 tools in context before the user asks anything” problem, while one result contract gives client authors a single shape to build against. This is a prioritization doc, not a shipped spec, so treat it as direction, not final API.
blog.modelcontextprotocol.io

Google Cloud published five patterns for long-horizon agents: stable prefixes, background learning, persistent workspaces, explicit failures, and guard chains. These are the bugs that do not crash; they quietly burn cache, lose memory, wipe tools, or mark timed-out sub-agents as done. Steal the checklist before the framework.
https://x.com/GoogleCloudTech/status/2090248297214525569

Someone fine-tuned Gemma 4 12B for tool calling and reported a 2.7x improvement, picking that model because it fits comfortably in 16GB of VRAM. Tool-calling reliability is the failure most teams paper over with retries and validators, and this says it is trainable on a card you already own.
reddit.com/r/LocalLLaMA

OpenAI’s Codex lead Tibo pointed to two drivers behind rate-limit pain: image-heavy long sessions with repeated compactions, and Computer Use getting expensive at p95+. You cannot fix Codex’s limits, but you can stop burning them on avoidable session shape. Keep images out of runs you expect to compact. x.com/thsottiaux

🔧 Clone and Run

 Clone & Run of the Day
Apache Maka is a local-first agent workspace that logs model messages, tool calls, permissions, and termination events as first-class records. The useful part is logging the two things you usually lose after a bad run: who approved what, and how the agent stopped. Still in Apache incubation, so treat it as early infrastructure. github.com/apache/maka

Paseo is an open-source control surface for Claude Code, Codex, Copilot, and OpenCode across local machines and a VPS. If your agent setup is currently tmux, SSH, and too many panes, this is the cleaner version of the layer you are already rebuilding.
github.com/getpaseo/paseo

Anthropic’s claude-plugins-community is a read-only mirror of the Claude Code and Claude Cowork plugin directory. It shows what is actually in the marketplace, and gives plugin builders the official path to get listed.
github.com/anthropics/claude-plugins-community

OpenHuman is an open-source personal AI with local-first memory and agent-fleet orchestration. Most projects give you one or the other; this tries to put the memory store and the agent runner in the same local system. github.com/tinyhumansai/openhuman

agent-safe-pipeline is a reference architecture where agents can propose actions but cannot approve them. It keeps intent capture immutable and sends the final decision to an independent policy layer, which is where agent permissions belong.
github.com/decionis/agent-safe-pipeline

open-slide turns a prompt into an interactive deck by having coding agents write the React components. Generating the artifact as code instead of as a rendered file means the output stays editable by the same agent that made it.
github.com/1weiho/open-slide

Ruflo is an open-source meta-harness for deploying multi-agent swarms and coordinating autonomous workflows. If you want to see what the coordination layer looks like beyond one agent at a time, this is a large implementation to read.
github.com/ruvnet/ruflo

oh-my-subagents adds persistence and tracking to subagent workflows that are ephemeral by default. The reason you cannot answer what your subagent did last Tuesday is that nothing kept the run, and this is a small patch over exactly that gap.
github.com/ringlochid/oh-my-subagents

Awesome LLM Apps (134k+ 🌟 ) is a curated collection of 100+ AI Agents, Agent skills, and RAG apps. It covers models from OpenAI, Anthropic, Google, and open-source models like GLM, DeepSeek, and Qwen that you can run locally on your computer. (Now accepting GitHub sponsorships)

By the Number

Number of the Day
Together Compute’s routing math puts GLM-5.3 at 17 solves per $100 on DeepSWE, versus 3 solves per $100 for Fable 5. That is the number that matters if your agent can retry: not which model wins once, but which model gives you more passing runs per dollar.
x.com/togethercompute

Researchers ran GLM-5.2 753B at 14.9 tok/s on a 96GB GPU, DeepSeek-V4-Flash 284B at 22 tok/s on 32GB, and Qwen3.6-35B at 39.3 tok/s on an 8GB card. If the setup holds, “too big to serve locally” just moved down a tier. The 8GB Qwen number is the one most readers can actually try.
arxiv.org

a16z reports the fastest-growing Codex adopters since February are outside tech: legal up 108x, sales and recruiting 41x, marketing 26x, healthcare 24x. The first non-engineering power users are not “vibe coding.” They are turning repeatable knowledge work into Codex-shaped tasks.
a16z.news 

That’s all for today. Come back tomorrow for the next batch of AI tools, model drops, agent repos, and weird benchmarks worth your time.

If you found one thing to try, share the issue with someone who ships.

Unwind AI - X | LinkedIn | Threads

Awesome LLM Apps | Sponsor Us

Today’s top AI Highlights:

1. Google Cloud turns scattered knowledge into agent-readable files

2. Vibe is here: one agent for work and code

3. Run GLM 5.2 locally

4. Telegram bots can now talk to other bots

5. Open-source alternative to Loom, Granola, and Wisprflow

& a lot more!

Read time: 3 mins

AI Tutorial

Generative UI Is the New Frontend

The frontend used to be a fixed thing. Designers drew it. Engineers built it. Users got what shipped.

That's over.

The interfaces shipping in 2026 are drawn partly by the agent itself, in real time, from what the user actually asked for. Ask for a table, get a table. Not a paragraph describing one.

Generative UI is the layer that lets agents stop describing and start showing.

This guide walks you through three patterns that have emerged on how to build it, and the differences between them matter more than most teams realize.

Generative UI Is the New Frontend

How AI agents stop describing and start showing

Don’t forget to share this newsletter on your social channels and tag Unwind AI (X, LinkedIn, Threads) to support us!

Latest Developments

Google Cloud Turns Company Knowledge Into Agent-Readable Files 🧠📁

Every team building internal agents eventually hits the same wall: the model is smart, but the context is scattered everywhere.

Part of it lives in data catalogs. Part of it lives in wikis. Part of it lives in code comments, dashboards, tribal knowledge, and that one senior engineer's brain.

Google Cloud just introduced Open Knowledge Format (OKF) to make that context portable. It is a vendor-neutral spec that turns enterprise knowledge into Markdown files with YAML frontmatter, so agents can read it, search it, version it, and move it between tools without another custom integration.

The nice part is how boring the format is. Just Markdown. Just files. Just a small set of structured fields like type, title, description, resource, tags, and timestamp.

That is exactly why it could work. Agents do not need another complex metadata platform; they need context they can actually open, inspect, and use.

Key Highlights:

1. Markdown-first: OKF represents context as human-readable Markdown, so engineers can review it in normal editors and agents can index it without special tooling.

2. Structured enough for agents: YAML frontmatter adds queryable fields like type, title, resource, tags, and timestamp without turning the whole thing into a heavy schema project.

3. Portable by default: OKF bundles can live in Git, ship as files, mount on a filesystem, or move across tools without locking context inside one vendor's catalog.

4. Reference implementations included: Google shipped examples including BigQuery enrichment, a static HTML visualizer, sample bundles, and Knowledge Catalog ingestion support.

Vibe is here: one agent for work and code

Meet Vibe by Mistral, one agent and one licence across work and code. Vibe takes on long-running, multi-step work: catching up across your inbox and calendar, running deep research, drafting deliverables, and taking coding work from request to merged change, across the web app, your editor, and your terminal.

Key highlights:

1. Work Mode for complex, multi-stage tasks: Maps out a plan, gets your sign-off, then works across your connectors to carry it through. Every tool call and reasoning step is visible and expandable as it runs. 

2. Code Mode for remote coding sessions: Connect to GitHub, start sessions, and see them through to a pull request. Sessions run in an isolated sandbox, persist while your machine is off, and can run in parallel.

3. VS Code extension: Vibe now works across your whole project inside VS Code. Reads, edits, and runs commands in a side panel. Open files attach automatically, @ mentions pull in context from anywhere in your repo.

4. CLI updates: Skills become / commands. Permissions are session-scoped. /teleport moves a live session between your terminal and the cloud, history and approvals intact.

OpenRouter Fusion Makes Model Panels a One-Call Primitive 🧪🤝

The most annoying part of using multiple models is that you usually have to become the router yourself.

You ask one model, compare it with another, maybe try a third, then manually decide which answer is right.

OpenRouter's new Fusion API turns that pattern into a single call. You send a prompt to Fusion, it dispatches the task to a panel of models in parallel, gives them web search and web fetch, then uses a judge model to compare the answers before producing the final response.

The results are worth paying attention to: Fable 5 + GPT-5.5 fused together scored 69.0% on DRACO, beating every individual model in OpenRouter's test, including Fable 5 alone at 65.3% and GPT-5.5 alone at 60.0%. That matters because Fable 5 is Anthropic's strongest model, and Fusion still found extra lift by pairing it with another frontier model instead of treating one model as the ceiling.

OpenRouter also tested a budget panel with Gemini 3 Flash, Kimi K2.6, and DeepSeek V4 Pro. That panel scored 64.7%, beating GPT-5.5 and Claude Opus 4.8 individually, coming within about one point of Fable 5 alone, and doing it at roughly half the cost.

The real story is not just the benchmark. It is that model diversity is becoming a product primitive. Instead of picking one model and hoping it is the right one, builders can start treating models like a small research team.

You can use it through the normal OpenRouter API. Just call openrouter/fusion directly or configure the Fusion plugin with your own analysis models and judge model.

Quick Bites

Everyone is talking about loop engineering, but Addy's version makes it usable
Addy Osmani's piece is useful because it turns the phrase into an actual operating model. The shift is from "I prompt the agent" to "I design the loop that finds work, hands it to agents, checks the result, records state, and decides the next step."

That is a better frame for where coding agents are going. The prompt is no longer the main artifact. The loop is. If you are building agent workflows, this gives you a cleaner way to think about retries, memory, evaluation, escalation, and token cost before you wire everything together.

Sakana Fugu explores orchestration as the model
Sakana's Fugu is interesting because it is less about launching another standalone model and more about coordinating multiple models into a stronger system. The bet is that intelligence can come from routing, combining, challenging, and arbitrating models, not only from scaling one model in isolation.

That makes it rhyme with the Fusion story, but from a research direction rather than an API product. The useful takeaway for builders is simple: the next frontier may be systems that know which model to use, when to ask for disagreement, and how to merge partial answers without making the user manage the whole process.

Telegram bots can now talk to other bots
Telegram's latest bot update lets bots respond to other bots, not just humans. That sounds small, but it changes what Telegram can be used for: not just a chat UI, but a lightweight coordination layer for agent workflows.

You could mention one bot, that bot could hand work to another bot, and the whole exchange stays visible in a normal chat thread.

Run GLM-5.2 locally with Unsloth
Unsloth just published a guide for running GLM-5.2 with Dynamic GGUFs, including 1-bit and 2-bit quant options, llama.cpp instructions, and Unsloth Studio support. The 2-bit build is still huge at around 239GB, but that is dramatically smaller than the full 1.51TB model.

This is not casual laptop territory, but it is meaningful for local-agent builders with serious memory available. A 744B-parameter open model with 40B active parameters and a 1M context window is already being squeezed into setups that advanced users can actually experiment with.

Tools of the Trade

1. Birdclaw: A local-first Twitter workspace that imports your X archive, syncs timeline/bookmarks/mentions, and stores everything in SQLite. The useful part is that your X memory becomes searchable and agent-readable: you can full-text search old likes and bookmarks, triage mentions with AI ranking, generate local digests, and keep a Git-friendly backup instead of losing everything inside the platform UI.

2. Agent-Native Clips: An open-source Loom + Granola + Wisprflow-style app for screen recordings, meeting notes, and dictation. Every clip gets transcripts, summaries, timestamped frames, and searchable history, so an agent can understand what happened in a video or meeting without needing raw audio/video ingestion.

3. Stripe Directory: A public-preview Stripe CLI directory for discovering businesses and services on the Stripe network. Developers and agents can search providers by keyword, then get structured results for Stripe Apps, Projects.dev providers, machine-payment endpoints, and business profiles instead of manually hunting across docs and marketplaces.

4. Awesome LLM Apps (113k+ 🌟 ) - A curated collection of LLM apps with RAG, AI Agents, multi-agent teams, MCP, voice agents, and more. The apps use models from OpenAI, Anthropic, Google, and open-source models like DeepSeek, Qwen, and Llama that you can run locally on your computer.
   (Now accepting GitHub sponsorships)

That’s all for today! See you tomorrow with more such AI-filled content.

Don’t forget to share this newsletter on your social channels and tag Unwind AI to support us!

Unwind AI - X | LinkedIn | Threads

Awesome LLM Apps | Sponsor Us

PS: We curate this AI newsletter every day for FREE, your support is what keeps us going. If you find value in what you read, share it with at least one, two (or 20) of your friends 😉 

Today’s top AI Highlights:

1. Apple Core AI Framework for on-device agents

2. Printing Press: Print agent-native CLIs from a single prompt

3. Claude Code Dynamic Workflows with massive parallelism

4. Your job is to write agent loops now

5. ChatGPT now "dreams" to build better memory

& so much more!

Read time: 3 mins

AI Tutorial

Generative UI Is the New Frontend

The frontend used to be a fixed thing. Designers drew it. Engineers built it. Users got what shipped.

That's over.

The interfaces shipping in 2026 are drawn partly by the agent itself, in real time, from what the user actually asked for. Ask for a table, get a table. Not a paragraph describing one.

Generative UI is the layer that lets agents stop describing and start showing.

This guide walks you through three patterns that have emerged on how to build it, and the differences between them matter more than most teams realize.

Generative UI Is the New Frontend

How AI agents stop describing and start showing

Don’t forget to share this newsletter on your social channels and tag Unwind AI (X, LinkedIn, Threads) to support us!

Latest Developments

Apple Just Gave Developers Their Own On-Device AI Framework

Forget calling external APIs. Apple's new Core AI framework, announced at WWDC 2026, gives developers Swift-native access to Apple's on-device foundation models with tool calling, structured generation, and full Apple Intelligence integration.

This is the first time Apple has opened up its on-device models as a developer-facing framework. You write Swift, define tools, and the model runs locally on the device with zero cloud round-trips. Privacy-first by default, no API keys, no usage-based pricing, no latency from network calls. For anyone building iOS or macOS apps, this changes how you think about adding intelligence to your product.

The bigger picture: Apple also revealed that Apple Intelligence is now co-developed with Google using Gemini models under the hood, running both on-device and through Private Cloud Compute. A system orchestrator automatically coordinates AI features across apps.

Key Highlights:

1. Tool calling in Swift: Define custom tools that the on-device model can invoke, enabling agentic workflows entirely on the user's device without a server.

2. Structured generation: Get typed, schema-conforming outputs from the model, not just raw text. Build reliable features without post-processing hacks.

3. Gemini under the hood: Apple Intelligence now runs on foundation models co-developed with Google, giving the platform multimodal capabilities, including image generation, visual Q&A, and speech generation.

4. No cloud dependency: Models run locally. Your users' data stays on their devices. No API costs, rate limits, or cold starts.

5. Available now: Core AI ships with iOS 27, macOS 27, and the latest Xcode. Documentation is live at developer.apple.com/documentation/coreai.

Print an Agent-Native CLI for Any API from a Single Prompt

What if every app, API, and website your agent needs came as a purpose-built CLI with a local SQLite mirror, compound commands, and token-efficient output?

That's Printing Press by Matt Van Horn and Trevin Chow. Point it at an API spec, a website URL, or even a service with no public API, and it generates a Go CLI, a Claude Code skill, an OpenClaw skill, and an MCP server. All from one prompt.

Super interesting concept: a local SQLite mirror beats a remote API call. Compound commands beat ten round trips. An agent-native CLI beats raw HTTP. When you "print" an ESPN CLI, you don't get a thin wrapper around REST endpoints. You get live scores, series state, leading scorers, and injury news in one call, all queried from a local database that syncs incrementally. Same goes for Linear, Slack, Notion, or any of the 237+ CLIs in their Public Library.

Key Highlights:

1. No API needed: For services without a public API, Printing Press launches a browser, captures traffic, reverse-engineers the endpoints, and generates the spec automatically. If you can click through it, the press can build a CLI.

2. Local-first data layer: High-gravity resources get domain-specific SQLite tables with FTS5 full-text search and incremental sync. Queries run in milliseconds offline. Your agent never waits for a 429.

3. 237+ community CLIs: The Public Library ships pre-built CLIs across 19 categories, from flight search to restaurant reservations to eBay auctions. Install with one command or let your agent browse and pick what it needs.

4. Token-efficient by default: --compact mode cuts 60-80% of tokens. Auto-JSON when piped. Typed exit codes for agent self-correction. The CLI is built for agents first, humans second.

5. Try it now: Install via Go, add the Claude Code or OpenClaw skills, and run /printing-press <app> inside your agent. Check it out at printingpress.dev.

Claude Code Can Now Orchestrate 100s of Parallel Agents on a Single Task

Some problems are too big for one agent in one pass. A bug hunt across an entire service. A migration that touches hundreds of files. A plan you want stress-tested from every angle before committing.

Anthropic's Dynamic Workflows for Claude Code changes the math entirely. Claude writes a custom JavaScript orchestration script on the fly, fans work out across 100s of parallel subagents, has independent agents try to break each other's results, and keeps iterating until answers converge. The coordination lives in code, not context, so the plan stays on track no matter how big the task gets.

The proof of concept is wild: Jarred Sumner used Dynamic Workflows to port Bun from Zig to Rust. 750,000 lines of Rust, 99.8% test suite passing, eleven days from first commit to merge. Hundreds of agents worked in parallel with two reviewers on each file.

Key Highlights:

1. Claude writes the orchestrator: No pre-built templates. Claude generates a bespoke JS script tailored to your specific task, then runs it. Every workflow is custom.

2. Independent verification built in: Agents tackle the problem from different angles, other agents try to refute what they found, and the run iterates until results converge. This is how it catches things a single pass misses.

3. Resumable and saveable: Progress is checkpointed. Interrupted jobs pick up where they left off. Save a workflow as a reusable /command for future sessions with structured input parameters.

4. Token warning: These workflows consume meaningfully more tokens than a typical session. Start with a scoped task to get a feel for usage before throwing it at your whole codebase.

5. Available now: Research preview on Max, Team, and Enterprise plans, plus the Claude API, Amazon Bedrock, Vertex AI, and Microsoft Foundry. Requires Claude Code v2.1.154+. Turn on ultracode effort level or just ask Claude to "create a workflow."

Quick Bites

Don’t Prompt Agent, Design Loops that prompt your agent (WTF!)
Peter Steinberger posted six words on Saturday that hit 6.3 million views: "You should be designing loops that prompt your agents." Boris Cherny, the creator of Claude Code, said the same thing a few days earlier: "I don't prompt Claude anymore. I have loops running. They're the ones prompting Claude." If all of this chatter left you wondering what the hell a loop even is, Matt Van Horn wrote the definitive explainer. He traces the concept all the way back to the 2022 ReAct paper, through Geoffrey Huntley's ralph loop, to today's multi-agent orchestration loops that run on cron and survive restarts. Worth the read.

Apple Intelligence, take two
Remember when Apple announced Apple Intelligence with ChatGPT as the backup brain at WWDC 2024? The "smart Siri" with personal context, on-screen awareness, etc? Most of it never shipped, and apparently, “it wasn't good enough" and "didn't converge quality-wise." Two years later, they're trying again, this time with Google. The new Apple Intelligence, announced at WWDC yesterday, is co-developed with Google using Gemini as the foundation, not just a fallback. On-device and Private Cloud Compute, multimodal everything, and a conversational Siri that's getting its own standalone app.

ChatGPT now "dreams" to remember you better
OpenAI shipped Dreaming V3, and the name is apt. ChatGPT now runs a background memory synthesis process when you're not chatting, analyzing your conversation history and building a unified "Memory Summary" that stays current over time. The old "saved memories" approach (manually saying "remember this") is gone. Now it automatically captures context from natural conversation and updates temporal facts, so it knows your Singapore trip is in the past, not upcoming. Available on Plus and Pro now, rolling out to free users soon after a 5x compute reduction made it feasible at scale. The direction is clear: persistent, stateful AI assistants where memory is infrastructure, not a feature you toggle on.

Google Research tackles RAG's biggest problem
Standard RAG retrieves once and hopes for the best. Google Research's new "Agentic RAG" for their Gemini Enterprise Agent Platform retrieves, checks if it got enough, and goes back for more. The key innovation is a "Sufficient Context Agent" that inspects retrieved snippets, evaluates a draft response, identifies exactly what's missing, and sends targeted follow-up searches. It's a multi-agent pipeline: orchestrator, planner, query rewriter, search fanout, and synthesis. The result is a 34% accuracy improvement over standard RAG on factuality benchmarks with negligible latency overhead. The pattern is the real takeaway here, even if you're not on Google Cloud.

Tools of the Trade

1. Agent-Reach: Deploy one AI agent across Telegram, Discord, Slack, WhatsApp, Web, and CLI simultaneously from a single codebase. It normalizes messages into a consistent format per platform and auto-adapts responses. Ships with ready-made adapters for LangChain, CrewAI, and AutoGen.

2. claude-howto: A visual, example-driven guide to Claude Code covering everything from basic setup to advanced workflows like multi-agent orchestration and custom skills. Super useful whether you're just starting with Claude Code or trying to level up.

3. last30days-skill: An agent skill that synthesizes research across X, Reddit, HN, YouTube, TikTok, and GitHub from the last 30 days on any topic you give it. Matt Van Horn used it to write that viral loops article, running it against the word everyone was fighting about.

4. agentcookie: Continuously syncs your browser cookies, bearer tokens, and API keys from your daily-driver Mac to a second Mac where your agents run, encrypted over Tailscale. Your agents wake up authenticated to every service you use, zero per-site login ceremony, no cloud middleman.

5. Awesome LLM Apps (113k+ 🌟 ) - A curated collection of LLM apps with RAG, AI Agents, multi-agent teams, MCP, voice agents, and more. The apps use models from OpenAI, Anthropic, Google, and open-source models like DeepSeek, Qwen, and Llama that you can run locally on your computer.
   (Now accepting GitHub sponsorships)

That’s all for today! See you tomorrow with more such AI-filled content.

Don’t forget to share this newsletter on your social channels and tag Unwind AI to support us!

Unwind AI - X | LinkedIn | Threads

Awesome LLM Apps | Sponsor Us

PS: We curate this AI newsletter every day for FREE, your support is what keeps us going. If you find value in what you read, share it with at least one, two (or 20) of your friends 😉 

The frontend used to be a fixed thing. Designers drew it. Engineers built it. Users got what shipped.

That's over.

The interfaces shipping in 2026 are drawn partly by the agent itself, in real time, from what the user actually asked for. Ask for a table, get a table. Not a paragraph describing one.

Generative UI is the layer that lets agents stop describing and start showing. Three patterns have emerged for how to build it, and the differences between them matter more than most teams realize.

But there isn't one way to build this. There are three. And most teams pick one without knowing they chose.

The protocol stack

Three protocols. Each does one job.

MCP connects agents to tools. A2A connects agents to each other. AG-UI connects agents to users.

AG-UI is the streaming layer that carries everything you'll see below: tool calls, A2UI schemas, MCP App events, state deltas. Runs over SSE. State flows both ways on the same stream. User edits, agent sees. Agent mutates, user sees.

A2UI is Google's spec for agents emitting UI as schema. It rides on AG-UI. CopilotKit ships it in production.

You don't write a parser for any of this. CopilotKit is an AG-UI client and decodes the stream for you.

The three patterns most teams confuse

Ask ten developers what Generative UI is. You get ten answers. Most of them are describing whichever pattern their current framework ships.

There are just three. The spectrum runs from more control to more flexibility.

• Controlled: You pre-build the components. The agent picks which to render.

• Declarative: The agent emits a schema. Your app maps it to components.

• Open-ended: The agent writes raw HTML. Your app renders it in a sandbox.

Every Gen UI framework in 2026 lives somewhere on this line. The differences are architectural, not cosmetic. Each pattern breaks your app in a different way at scale.

I tried different stacks. Most cover one pattern well. Landed on CopilotKit because it supports all three on the same runtime, riding AG-UI. That's the stack everything below runs on.

Pattern 1: Controlled, frontend owns the UI

This is where most teams start. It's also where most teams get stuck.

You pre-build a React component. You bind it to a tool name. The agent picks that tool and the component renders inline in chat with the agent's args as props.

One frontend hook. Zero agent code. That's it.

"use client";
import { z } from "zod";
import { useComponent } from "@copilotkit/react-core/v2";

const expenseChartSchema = z.object({
  title: z.string(),
  data: z.array(z.object({ label: z.string(), value: z.number() })),
});

function ExpenseChart({ title, data }: z.infer<typeof expenseChartSchema>) {
  return (
    <section className="rounded-xl border p-4">
      <h3 className="text-sm font-medium">{title}</h3>
      <ul className="mt-2 grid gap-1">
        {data.map((d) => (
          <li key={d.label} className="flex justify-between text-sm">
            <span>{d.label}</span>
            <span>${d.value}</span>
          </li>
        ))}
      </ul>
    </section>
  );
}

export function ExpensesCopilot() {
  useComponent({
    name: "showExpenseChart",
    description: "Render a breakdown of expenses by category.",
    parameters: expenseChartSchema,
    render: ExpenseChart,
  });

  return null;
}

The hook registers the tool with CopilotKit's runtime. The runtime advertises it to the agent over AG-UI. When the agent calls it, the args stream in and your component renders inline. No Python tool to write, no schema to wire, no API route to add.

Your design system stays in charge.

That expense chart isn't a mockup. The AI Financial Coach Agent renders cards just like it for real budgets, savings plans, and debt payoff.

Want the bare hook first? It's 'use-generative-ui-examples.tsx' in the Generative UI Starter Project.

The token tax

Every component you register sits in the agent's context window before the user has said anything. A typical tool description with its JSON schema runs around 400 tokens. 25 components are 10,000 tokens on every turn. You pay that tax per request.

The agent picks the wrong component too. Too many look similar. Pie chart and donut chart both "show proportions." It guesses.

When to add agent-side state

Shared state is the one case where writing a Python tool is worth it. The agent writes to session state. Other parts of the UI subscribe and re-render with no second LLM call. Pin a metric, the dashboard updates. Add a row, the table redraws.

from google.adk.agents import LlmAgent
from google.adk.tools import ToolContext

def pin_metric(tool_context: ToolContext, label: str, value: float) -> dict:
    """Pin a metric to the user's dashboard."""
    pinned = tool_context.state.get("pinnedMetrics", [])
    tool_context.state["pinnedMetrics"] = pinned + [{"label": label, "value": value}]
    return {"status": "pinned"}

agent = LlmAgent(name="dashboard_agent", model="gemini-3.5-flash", tools=[pin_metric])

The frontend reads pinned metrics through CopilotKit's shared-state hook. The chat component still renders inline because the same tool name is wired with the frontend hook.

Pin a metric in chat. The panel redraws with no second model call. That's the AI Dashboard Canvas Agent.

The AI Deep Research Agent takes it further. The plan, every search, each file write, all of it streams in as live cards. For everything else, the frontend hook is the whole story.

When to ship Controlled: Ten or fewer high-value flows. Design precision matters. You know the exact UIs you need.

When not to: Your codebase grows linearly with use cases. 25 components means 25 tool definitions sitting in every agent turn.

What breaks: Agent picks the wrong component. Two tool descriptions overlap semantically. Past 15 tools, two of them probably read like "displays data." Fix: rewrite descriptions to name the user intent, not the visual. "Use when the user asks to compare proportions of a whole" beats "renders a pie chart."

Pattern 2: Declarative (A2UI), agent emits schema

This is the pattern most production agent apps end up needing.

The agent emits a JSON schema describing the UI. Your app has a catalog of components that maps schema nodes to React (or Svelte, Flutter, anything). One tool. Many UIs.

A2UI is the standard spec. CopilotKit ships the runtime. ADK runs the agent. AG-UI is the wire.

The agent tool returns three operations in order: create a surface, push the component tree, push the data.

def search_flights(flights: list[Flight]) -> dict[str, Any]:
    """Search flights and display them as rich cards."""
    return {
        "a2ui_operations": [
            {"type": "create_surface", "surfaceId": SURFACE_ID, "catalogId": CATALOG_ID},
            {"type": "update_components", "surfaceId": SURFACE_ID, "components": FLIGHT_SCHEMA},
            {"type": "update_data_model", "surfaceId": SURFACE_ID, "data": {"flights": flights}},
        ]
    }

The component tree above lives in flights.json. You wrote it. The agent only fills in the data. That's a fixed schema.

Dynamic schema flips it: a secondary LLM writes the component tree per turn from conversation context. Same a2ui_operations container at the end. The Google ADK showcase ships both.

The catalog is the contract

Definitions list the components the agent is allowed to emit, with Zod schemas for the props. Renderers fill in React. Typos become build errors instead of blank screens.

const renderers: CatalogRenderers<TravelDefinitions> = {
  FlightCard: ({ props }) => (
    <article className="rounded-xl border p-4">
      <header className="flex justify-between">
        <span>{(props as any).airline}</span>
        <span>{(props as any).price}</span>
      </header>
      <div className="text-sm text-muted-foreground">
        {(props as any).origin} → {(props as any).destination} · {(props as any).departureTime}
      </div>
    </article>
  ),
};

export const travelCatalog = createCatalog(travelDefinitions, renderers, {
  catalogId: "copilotkit://travel-catalog",
  includeBasicCatalog: true,
});

Both halves live in the Generative UI Starter Project, wired and matched. search_flights in 'a2ui_fixed_schema.py', the FlightCard catalog in 'renderers.tsx'. Ask for flights. Watch the cards stream into chat.

Buttons and other interactive components carry an action in the schema. The basic catalog wires it to onClick. Click fires an event back to the agent over AG-UI. The agent decides what to render next. Zero click handlers.

The token math

50 card types or 500, the agent sees one function. Tokens per turn stay flat as your component library grows.

Extensible to any rendering framework because it's just JSON. Any agent that already speaks AG-UI can drive A2UI on day zero. You don't touch agent code to wire this up.

Trade-off: The LLM owns the layout. Output varies run to run within your catalog. If you're shipping legal disclosures, marketing surfaces, or anything where exact pixel placement matters, this is not your bucket.

Declarative is the pattern built for the long tail. Dashboards, results, forms, cards, widgets.

When to ship Declarative: You have more use cases than time to pre-build. You care about token economics past the prototype stage.

What breaks: Built a custom FlightCard. Every flight renders as the basic catalog's generic card. No error in the console. The CATALOG_ID on the agent and catalogId in createCatalog on the frontend don't match. Frontend doesn't recognize the catalog the agent is targeting, falls back to basic. Match the strings exactly on both sides.

Pattern 3: Open-ended, no catalog, no rules

The third pattern is the opposite extreme. No catalog. No schema. Just a blank canvas.

Two sub-patterns live in this bucket.

MCP Apps

An MCP server exposes UI surfaces that the agent drives. Excalidraw is the example that stuck with me. The agent gets full control of the canvas. Draws diagrams from your context. Owns every pixel on the board.

Implementing the client protocol from scratch is painful, so CopilotKit ships an MCPAppsMiddleware. Attach it to your agent and point it at any MCP Apps server.

const agent = new BuiltInAgent({
  model: "openai/gpt-5.5",
  prompt: "You are a helpful assistant.",
}).use(
  new MCPAppsMiddleware({
    mcpServers: [{ type: "http", url: "https://mcp.excalidraw.com/mcp", serverId: "my-server" }],
  }),
);

Spin up the MCP Apps Showcase and you're booking flights and reserving hotels inside the chat window. Same middleware, real MCP servers. Or go further.

The AI MCP App Builder lets the agent write a brand-new app into an E2B sandbox, then renders it live.

Sandboxed HTML

The agent writes raw HTML. Your app renders it inside a sandboxed iframe so it can't hijack the session.

The runtime registers an HTML rendering tool and ships it to the agent over AG-UI. The agent calls it with whatever markup it wants. There is no HTML tool to define on the agent side. The runtime injects it.

Agent-side instruction is doing real work:

canvas_agent = LlmAgent(
    name="canvas_agent",
    model="gemini-3.5-flash",
    instruction=(
        "You are a visualization assistant. When the user asks to see, "
        "draw, or visualize anything, generate an interactive HTML UI. "
        "Use Tailwind classes only. No external fonts. Stick to neutral "
        "colors unless the user names one."
    ),
)

Without those style rules, the model defaults to whatever aesthetic was loudest in its training data that week. With them, you get something close to your brand most of the time. Not always.

The brand inconsistency problem

I tried shipping Open-ended as the primary UI for an agent. Pulled it in a week.

"Neo-brutalist" on Tuesday. "iOS 4 clone" on Wednesday. Style rules in the prompt nudge the agent toward your brand. They don't guarantee it. The brand kept changing. The product felt unserious.

Open-ended isn't useless. It's misapplied.

Right call for one thing: throwaway interactions where the user doesn't care what the interface looks like and will never see it again. "Show me how electrons work." "Give me a weird bar chart of my last 10 queries." "Visualize this API response." The kind of thing you see in Google AI overviews.

When to ship Open-ended: One-shot queries. Disposable visualizations. Sandboxed experiments. Never as the primary surface.

What breaks: The iframe renders. Buttons don't click. Forms don't submit. Sandbox flags are too tight, or too loose in a way the browser refuses. Set the iframe sandbox to allow scripts and allow forms. Nothing else. Never allow-same-origin.

How to pick

Run the decision tree before you write code.

Designer has pixel-perfect mockups for this flow? Controlled.

Dozens of card types or widgets to ship? Declarative.

One-shot, throwaway visualization the user will never see twice? Open-ended.

Can't decide? Default to Declarative. Upgrade to Controlled for the top 3 flows. Never Open-ended as the default.

If you're already shipping and not sure where you landed, count the render tools. Past 15, you're in Controlled and the wall is close. Start wiring A2UI this week.

Three patterns. Three bets.

Controlled bets on you. Pre-built components, pixel-perfect. Expensive past 25 of them.

Declarative bets on the schema. The schema is the contract. The agent fills it in. Scales flat.

Open-ended bets on the model. No catalog, no schema, raw HTML. Good for throwaway. Brittle for anything that ships twice.

The mistake isn't picking the wrong pattern. It's not knowing you picked one.

Most teams default to Controlled because the framework defaults to Controlled. They hit the wall at 25 components and reach for Open-ended because it looks compelling in demos. Neither was a decision. Both were drift.

Pick on purpose. Match the pattern to the problem. Controlled for the flows that need to be exact. Declarative for the long tail. Open-ended for the disposable.

🚨 Open Source Generative UI Agent Templates

The reference for all three lives in the new Generative UI Agents section of awesome-llm-apps. Clone what you need. Rip out what you don't.

I'll be publishing more about shipping agents in production, AG-UI, and the patterns that scale.

Follow me @Saboo_Shubham_ to stay tuned.

We share in-depth blogs and tutorials like this 2-3 times a week, to help you stay ahead in the world of AI. If you're serious about leveling up your AI skills and staying ahead of the curve, subscribe now and be the first to access our latest tutorials.

Don’t forget to share this tutorial on your social channels and tag Unwind AI (X, LinkedIn, Threads) to support us!

Today’s top AI Highlights:

1. OpenAI Codex Can Now Ship Live Websites

2. Hermes Agent now has a desktop app

3. Open-source Alternative to Exa Websets

4. Microsoft launches 7 in-house MAI models at Build

5. Open-source code review tool from the OpenClaw team

& so much more!

Read time: 3 mins

AI Tutorial

The Ultimate Guide to /goal

HTTP is a primitive. JSON is a primitive. /goal is becoming one for coding agents.

A few weeks ago, OpenAI's Codex CLI added /goal as a way to give the coding worker a job with a defined done state. Claude Code added it this week.

Hermes Agent, the orchestrator I run on a Mac Mini to coordinate work between coding workers, has had /goal built in for a while.

This guide walks through what /goal actually is, the three roles in a multi-agent setup, a real end-to-end run, the verification rule, and how to run goals in parallel without workers stepping on each other.

Read The Ultimate Guide to /goal

Don’t forget to share this newsletter on your social channels and tag Unwind AI (X, LinkedIn, Threads) to support us!

Latest Developments

OpenAI Codex Can Now Ship Live Websites

Your Codex session doesn't have to end with a file sitting on your machine anymore.

Sites lets Codex publish its work as a hosted, interactive website with a shareable URL. Dashboards, scenario planners, project trackers, launch hubs, whatever you're building, it goes live with a link you hand to your team.

You can even ask Codex to keep the site up to date as things change. Not static pages either. These are collaborative canvases your whole workspace can explore and contribute to.

Key Highlights:

1. Annotations for precise refinement: Point to the exact part of a site, doc, spreadsheet, or slide you want changed. Codex updates just that piece without starting over. Think inline editing, but AI-powered.

2. Rolling out now: Sites are in preview for Business and Enterprise teams, expanding broadly soon.

And it's not just Sites. OpenAI is going really heavy on making Codex the tool for non-technical knowledge work.

They shipped six open-source, role-specific plugins that each bundle apps, skills, and workflows for a specific job function. Data Analytics connects Snowflake, Databricks, Hex, and Tableau. Creative Production hooks into Figma, Canva, and Picsart. Sales brings in Salesforce, HubSpot, and Clay. There's also Product Design, Equity Investing, and Investment Banking.

62 apps and 110 skills across all six.

Plugins work out of the box, but you own them. Every plugin can be adapted to your team's workflows. Build and share custom ones too. Corporate Finance, Private Equity, Marketing Strategy, and Legal plugins are coming next.

Non-developers already make up 20% of Codex's 5 million weekly users and are growing 3x faster than developers. OpenAI is clearly building for that curve.

Hermes Desktop is Here

Hermes Agent just got a native desktop app on macOS and Windows.

First demoed during Jensen Huang's GTC keynote, Hermes Desktop is now in public preview. Same agent, same memory, same skills, same everything, just no terminal required. Download the .dmg or .exe, and you're running.

The community has been using Hermes as a single interface for all their workflows, and has been actively growing the ecosystem around it. A native app lowers the floor for everyone who wants in but doesn't live in a terminal. If you're already running Hermes via CLI or messaging platforms, nothing changes. Desktop is just another surface, same agent underneath.

Download at hermes-agent.nousresearch.com/desktop. macOS 12+, Windows 10/11, or install via terminal on Linux.

Open-source Alternative to Exa Websets

Describe the dataset you want in one sentence. AI agents go build it for you.

BigSet is a new open-source tool from TinyFish that turns a natural language prompt into a structured, verified dataset pulled from the live web.

Say "YC companies currently hiring engineers, with their funding stage, location, and number of open roles" and BigSet infers the schema, fans out AI agents to research in parallel, deduplicates, and returns a clean table with citations that you can export as CSV or XLSX.

The real fun bit is you can set a refresh cadence (30 minutes to weekly) so the dataset stays fresh always.

Self-hosted via Docker in one command.

Key Highlights:

1. Schema inference from English: You describe what you want, BigSet figures out column names, types, and primary keys. No manual schema design.

2. Parallel agent research: Multiple AI agents fan out across the web simultaneously, verify data against real sources, and deduplicate before returning results.

3. Auto-refresh schedules: Set it and forget it. Datasets update on a cadence you choose, from every 30 minutes to weekly.

4. Full stack, open source: Next.js 16 frontend, Fastify backend, Mastra workflows for agent orchestration, powered by TinyFish's Search and Fetch APIs under the hood. AGPL-3.0 licensed.

Quick Bites

Microsoft finally built its own frontier models 
Microsoft dropped the new MAI family of models at Build, across text, image, voice, and speech. MAI-Code-1-Flash is the one to watch for devs, optimized specifically for fast, efficient coding tasks. MAI-Thinking-1 handles heavier reasoning and SWE work. Even the Image model is debuting at No. 3 on Arena.ai. Both are cheaper alternatives to OpenAI and Anthropic models. The word on the street is that Microsoft built these because relying on Anthropic's Claude was forcing them to raise GitHub Copilot prices and cap developer usage.

Your coding agent doesn't need the most expensive model for every task Factory just shipped Factory Router, and the idea is overdue: stop burning frontier-model tokens on tasks that a smaller model handles just as well. Router automatically picks the right model for each coding session and escalates to a more capable one only if the first choice struggles. On their benchmarks, it hits 99% of Claude Opus 4.7's pass rate at 20% lower cost. If the first model can't crack it, Router bumps to a heavier one automatically. Available now in Factory CLI and Desktop in private research preview.

Perplexity Computer splits work between local and cloud 
Perplexity announced hybrid agentic inference for Perplexity Computer: the system can now split tasks between a local model running on your machine and frontier models in the cloud. Private data stays on-device, token efficiency goes up, and you stop sending everything through an API. Coming soon, but architecturally, this is the direction everyone's heading.

Use Cursor's Composer 2.5 in any agent harness 
Someone built an open-source macOS app that exposes Cursor's Composer 2.5 as an API. That means you can now use Cursor's model routing in Codex, OpenCode, Cline, or whatever harness you prefer. If you've been locked into Cursor's editor just for the model quality, this unbundles it.

Tools of the Trade

1. ClawPatch: Open-source code review from the OpenClaw team that thinks in "feature slices" instead of files. It maps your codebase into semantic units (routes, commands, packages), sends bounded context to an AI for review, and then runs an explicit fix loop. Every finding gets a severity, confidence score, and audit trail. Works with Codex as the default AI provider.

2. Hermes WebUI: A 12.7K-star open-source web interface for Hermes Agent by Nathan Esquenazi (CodePath co-founder). Full CLI parity in a three-panel browser layout: sessions on the left, chat in the center, workspace file browser on the right. No build step, no framework, just Python and vanilla JS. MIT-licensed.

3. Email SDK: Unified TypeScript SDK that lets you send email through any provider: Resend, Postmark, SendGrid, Mailgun, Brevo, or raw SMTP. One clean API, swap providers by changing a config line. Built-in formatting, error handling, and type safety so you stop writing provider-specific glue code.

4. Awesome LLM Apps (111k+ 🌟 ) - A curated collection of LLM apps with RAG, AI Agents, multi-agent teams, MCP, voice agents, and more. The apps use models from OpenAI, Anthropic, Google, and open-source models like DeepSeek, Qwen, and Llama that you can run locally on your computer.
   (Now accepting GitHub sponsorships)

That’s all for today! See you tomorrow with more such AI-filled content.

Don’t forget to share this newsletter on your social channels and tag Unwind AI to support us!

Unwind AI - X | LinkedIn | Threads

Awesome LLM Apps | Sponsor Us

PS: We curate this AI newsletter every day for FREE, your support is what keeps us going. If you find value in what you read, share it with at least one, two (or 20) of your friends 😉 

Today’s top AI Highlights:

1. CLI-Anything: Every Software Just Became Agent-Native

2. Shared AI agents for teams in Slack

3. Microsoft SkillOpt: Train the Skill, not the model

4. Inference price war is here (and it’s starting from China)

5. LangChain gives agents a code layer between tool calls

& so much more!

Read time: 3 mins

AI Tutorial

The Ultimate Guide to /goal

HTTP is a primitive. JSON is a primitive. /goal is becoming one for coding agents.

A few weeks ago, OpenAI's Codex CLI added /goal as a way to give the coding worker a job with a defined done state. Claude Code added it this week.

Hermes Agent, the orchestrator I run on a Mac Mini to coordinate work between coding workers, has had /goal built in for a while.

This guide walks through what /goal actually is, the three roles in a multi-agent setup, a real end-to-end run, the verification rule, and how to run goals in parallel without workers stepping on each other.

Read The Ultimate Guide to /goal

Don’t forget to share this newsletter on your social channels and tag Unwind AI (X, LinkedIn, Threads) to support us!

Latest Developments

Every Software Just Became Agent-Native

Your agent can write code, search the web, and manage files. But ask it to edit a Blender scene, export a MuseScore sheet, or automate Rekordbox, and it hits a wall. The software doesn't speak agent.

CLI-Anything from the HKUDS lab fixes this by generating full CLI harnesses for any software, turning GUI-only apps into agent-controllable tools. One command analyzes the target app's source code, architects a CLI, implements it with tests, and publishes it to PATH. The project ships with a growing registry of 50+ ready-made CLIs covering GIMP, Blender, LibreOffice, OBS, Obsidian, Kdenlive, QGIS, and more.

The idea is simple but the implications are huge: if CLI is the universal interface both humans and LLMs already speak, then wrapping every piece of software in a CLI makes the entire software ecosystem agent-accessible overnight.

Key Highlights:

1. CLI-Hub package manager: pip install cli-anything-hub, then browse, search, and install any harness with cli-hub install <name>. Supports pip, npm, brew, and system tools.

2. 7-phase generation pipeline: Point it at a repo or app and it runs through analyze, design, implement, plan tests, write tests, document, and publish, fully automated by your coding agent.

3. Works with every major agent: Claude Code plugin, Pi extension, OpenCode commands, Codex, and OpenClaw skill. Each gets a native integration path.

4. Skills baked in: Every generated CLI ships with a SKILL.md so agents can discover and use it autonomously, no manual wiring needed.

5. Try it now: Install from PyPI or clone the repo. The CLI-Hub web registry is live at clianything.cc.

Shared AI agents for teams in Slack

We love our personal Hermes and OpenClaws. But how many of us have been running it for our professional work, with our teams, cross-functionally?

It’s a completely different set of problems: surviving laptop closures, handling real credentials securely, running for hours or days, and being reachable where the team actually works.

Centaur is the self-hosted runtime Paradigm and Tempo have been running internally since January, now open-sourced under Apache 2.0. It's a Slack-native multiplayer agent system where:

• every thread gets its own isolated Kubernetes sandbox,

• tools you add are instantly available to every conversation, and

• a credential firewall injects secrets in-flight so agents can never exfiltrate raw keys.

Tools are plain Python drop-ins that hot-reload across your org, workflows checkpoint to Postgres and resume exactly where they left off after a crash, and every night the system reviews its own performance and ships fixes to its own skills (super interesting!).

Clone from GitHub or visit centaur.run to get started.

Microsoft SkillOpt: Train the Skill, Not the Model

What if you could train agent skills the same way you train neural networks, with learning rates, mini-batches, epochs, and momentum, but entirely in text space?

SkillOpt from Microsoft Research does exactly that. Instead of fine-tuning model weights, it treats SKILL.md as a trainable external parameter. The frozen target model executes tasks, records scored trajectories, and a separate optimizer model proposes structured edits to the skill. Edits are accepted only when held-out validation performance improves.

The whole thing mirrors a training loop: rollouts are forward passes, reflection is a backward pass, and a textual edit budget acts as a learning rate to prevent destructive rewrites.

Evaluated across 6 benchmarks and 7 models, including real agent execution loops with Codex and Claude Code, SkillOpt achieves best or tied-best results in all 52 settings tested.

Key Highlights:

1. Improvement with Claude Code: On GPT-5.5 target model running through Claude Code, SkillOpt skills boosted performance by an average of 18.6 points across benchmarks, with Spreadsheet tasks jumping +58.3%.

2. Cross-model and cross-harness transfer: A skill trained with Codex transfers directly into Claude Code and gains +31.8% on SpreadsheetBench. Trained on GPT-5.4, transfers to GPT-5.4-nano and still gains +15.2%.

3. Self-optimizer mode works: Even when the target model is its own optimizer, the constrained, validated update loop still discovers useful edits.

4. Exports a single file: The whole optimization produces one best_skill.md file. The target model at deployment never sees the optimizer memory, rejected edits, or training state.

5. Open-source: The whole thing is open-sourced under MIT license. Go and try it out!

Quick Bites

The inference price war is here
DeepSeek just made its 75% price cut on V4-Pro permanent. Xiaomi's MiMo slashed V2.5 pricing by up to 99%, effective today. But this isn't a loss-leader race to the bottom. V4-Pro's hybrid attention architecture compresses its KV cache at 1M tokens to 10% of V3.2's, with single-token inference FLOPs at 27% of previous. V4-Pro now sits at $0.87 per million output tokens. A year ago, sub-dollar output pricing meant you were using a small distilled model with real capability tradeoffs. These are frontier-class reasoners.

ElevenLabs Launches Music v2
ElevenLabs just shipped Music v2 with better vocals, instrumentation, and arrangement across every genre, plus improved multilingual support and capabilities that weren't possible before. If you've used their v1 for music generation, this is a huge upgrade.

Cohere Drops Command A+: 218B MoE Under Apache 2.0
Cohere just open-sourced Command A+, a 218B parameter MoE model with only 25B active per token. It unifies all previous Command A variants (reasoning, vision, translation) into a single model, supports 48 languages, and runs on as little as two H100s at W4A4 quantization. On τ²-Bench Telecom, it jumped from 37% to 85% over Command A Reasoning. Apache 2.0, available on Hugging Face in BF16, FP8, and W4A4.

Microsoft Open-Sources Fara1.5 Browser Agents
Microsoft Research just dropped Fara1.5, a family of three open computer use agent models (4B, 9B, 27B) built on Qwen3.5 for browser automation. The 27B variant hits 72% on Online-Mind2Web, outperforming OpenAI Operator, Gemini 2.5 Computer Use, and Yutori Navigator n1. Even the 9B model at 63.4% beats every proprietary competitor. Available on the Microsoft Foundry now.

OpenAI Launches Secure MCP Tunnels
Your private MCP servers can now stay inside your network while ChatGPT, Codex, and the Responses API connect through outbound-only HTTPS. No inbound ports, no public endpoints, no VPN. If you've been holding off on connecting internal tools to OpenAI products because of network security concerns, this removes that blocker.

LangChain Gives Agents a Code Layer Between Tool Calls
Your agent calls a tool, reads the result, reasons, calls the next tool, reads, reasons, repeat. Every step is a model round trip. LangChain's Deep Agents now ships with interpreters — small QuickJS runtimes where the agent writes code that coordinates multiple tool calls, keeps intermediate state in the runtime, and returns only what matters. Early testing showed up to 35% fewer tokens on some tasks. Available in both Python and TypeScript.

Tools of the Trade

1. Codegraph: Pre-indexed code knowledge graph for Claude Code, Codex, Cursor, and more. Agents query symbol relationships and call graphs instead of scanning files, averaging 35% cheaper and 70% fewer tool calls. 100% local, MIT licensed.

2. Bumblebee: Perplexity's open-source supply chain scanner for developer machines. A single Go binary that checks lockfiles, package metadata, extension manifests, and MCP configs against exposure catalogs. Apache 2.0.

3. Sieve: macOS app that scans your Claude Code, Cursor, Copilot, Windsurf, and Codex chat history for accidentally leaked API keys, tokens, and passwords. Ships with an MCP server so Claude can check for exposed secrets itself. $9.99.

4. Awesome LLM Apps (111k+ 🌟 ) - A curated collection of LLM apps with RAG, AI Agents, multi-agent teams, MCP, voice agents, and more. The apps use models from OpenAI, Anthropic, Google, and open-source models like DeepSeek, Qwen, and Llama that you can run locally on your computer.
   (Now accepting GitHub sponsorships)

That’s all for today! See you tomorrow with more such AI-filled content.

Don’t forget to share this newsletter on your social channels and tag Unwind AI to support us!

Unwind AI - X | LinkedIn | Threads

Awesome LLM Apps | Sponsor Us

PS: We curate this AI newsletter every day for FREE, your support is what keeps us going. If you find value in what you read, share it with at least one, two (or 20) of your friends 😉