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 😉 

I’ve been thinking a lot about how much room we should actually give coding agents to work.  

Qwen3.7-Max running for 35 hours with 1,000+ tool calls makes long-horizon agents feel a lot more real. But today’s npm compromise is the less fun side of the same story: attackers are now targeting Claude Code and Codex hooks directly.  

So the takeaway is pretty simple. Agents are getting better at doing real work, but the workflows around them need stricter specs, better memory, and tighter boundaries before we hand them bigger jobs.

Today’s top AI Highlights:

1. Qwen3.7-Max: 35 hours, 1,000+ tool calls, zero human intervention

2. GitHub Spec Kit forces AI to spec before it codes

3. 314 npm packages compromised to hijack your coding agent

4. Google’s own version of hosted Hermes/OpenClaw

5. A design skill that refuses to look AI-generated

& 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

Qwen3.7-Max: 35 Hours, 1,000+ Tool Calls, Zero Human Intervention

What’s the maximum number of steps and tool calls you’ve seen an LLM doing without you babysitting? 20? 50? Max 100?

Qwen3.7-Max just ran a fully autonomous kernel optimization session for 35 hours straight, making over 1,000 tool calls.

Alibaba's Qwen Team released their latest model Qwen 3.7-Max, specifically for the agent era. It tops SWE-Pro at 60.6% (vs Opus 4.6's 48.2%), leads TerminalBench, and takes the crown on MCP-Mark. It also tops all the benchmarks on pure reasoning; best-in-class!

What makes it genuinely different is scaffold generalisation. You can plug it into Claude Code, OpenClaw, Hermes Agent, or Qwen Code and get consistent results without prompt gymnastics.

Key Highlights:

1. Reward hacking defense built in: During 80+ hours of RL training on SWE tasks, the model's monitoring system autonomously caught 1,618 reward hacking attempts and generated 13 new heuristic rules to block them. The model is training itself to be honest.

2. 1M token context, 65K output: Scores 90.4% on MRCR-v2 128K, far ahead of every competitor on long-context retrieval.

3. 48 languages natively: Leads multilingual benchmarks across the board, including WMT24++ translation and MMLU-ProX.

4. Pricing: Qwen 3.7 Max is roughly half the price of GPT-5.4 and less than a third of Claude Opus 4.6, while matching both on SWE-Pro and TerminalBench.

5. Closed source: Qwen3.7-Max is proprietary and will be available via Alibaba Cloud Model Studio API. Open-weight variants at smaller sizes are expected to follow.

GitHub Spec Kit forces AI to spec before it codes

Still throwing vague prompts at your coding agent and hoping it doesn't torch your project?

GitHub just open-sourced Spec Kit, a toolkit that makes the AI create a structured specification before it writes a single line of code. The agent figures out what you want, asks clarifying questions, plans the architecture, generates a task list, then implements. All structured, all inspectable, all before any code exists.

103K stars already. Works with 30+ coding agents out of the box: Claude Code, Cursor, Codex, Gemini CLI, Junie, and more. And it's completely stack-agnostic, so it doesn't care if you're writing Rust or Rails.

Key Highlights:

1. Structured before creative: The agent can't start coding until it's written a spec, asked clarifying questions, and planned the architecture. The sequence is enforced, not optional.

2. 30+ agent integrations: Works with Claude Code, Copilot, Gemini, Codex, Cursor, and pretty much every coding agent you're already using. Same spec, any agent.

3. Extensible via presets and extensions: Customize the workflow with your own templates. Runtime resolution follows a priority chain: project-local overrides beat presets beat extensions beat core.

4. MIT-licensed: Install via uv tool install from the GitHub repo. Full greenfield, exploration, and brownfield workflows supported out of the box.

314 npm Packages Compromised to Hijack Your Coding Agent

22 minutes. That's how long it took an attacker to publish 637 malicious versions across 317 npm packages with a combined 11+ million monthly downloads.

The compromised account "atool" pushed a payload from the "Mini Shai-Hulud" toolkit, the same one behind the SAP compromise three weeks ago. But the interesting bit is that the malware specifically targets AI coding agents. It injects Claude Code SessionStart hooks, Codex hooks, and VS Code "runOn: folderOpen" tasks. It harvests AWS credentials, Kubernetes tokens, SSH keys, GitHub PATs, and even 1Password and Bitwarden vaults. Exfiltration is disguised as OpenTelemetry traces to blend in with your existing observability stack.

Key Highlights:

1. Your coding agent is a vector: The payload hooks into Claude Code and Codex session startup, silently piping every credential it finds to a C2 server. If you're running these agents in environments with cloud access, this is as bad as it sounds.

2. Packages you probably use: size-sensor (4.2M downloads/month), echarts-for-react (3.8M), @antv/scale (2.2M), timeago.js (1.15M). Check your lockfile.

3. Persistent and stealthy: A LaunchAgent/systemd service called "kitty-monitor" survives reboots and uses GitHub commit search as a dead-drop C2 channel, polling for RSA-PSS signed commands.

4. Full advisory and IoCs available: SafeDep published the complete list of all 317 compromised packages with deobfuscated payloads and remediation steps.

Quick Bites

Andrej Karpathy joins Anthropic
Yesterday, he announced he's joined Anthropic. "The next few years at the frontier of LLMs will be especially formative," he wrote. He shaped the early GPT era at OpenAI, then left to build Eureka Labs for AI education. Now he's back in the lab at what might be the most interesting research org in the field right now. One to watch.

Google releases a managed personal 24/7 agent
Gemini App now comes with Spark, an always-on personal AI agent, running on Gemini 3.5 and built on Antigravity. It navigates your digital life and takes actions on your behalf, even when you close your laptop. You can set up cron jobs (schedule tasks), teach it new Skills, and create end-to-end workflows. Rolling out to trusted testers now, with beta access for Google AI Ultra subscribers next week.

Turn any chat agent into a voice agent with one prompt
ElevenLabs just shipped Speech Engine, and it’s pretty straightforward: keep your existing chat agent exactly as it is, add Speech Engine on top, and now it talks. You don’t need to rearchitect your LLM stack or swap out your RAG pipeline. It bundles speech-to-text, turn detection, interrupt handling, TTS, and audio orchestration into a single pipeline with ultra-low latency. Works with any LLM that produces text, has built-in stream extraction, and covers 70+ languages.

Google releases the Nano Banana of video-gen
Gemini Omni is Google's new any-input-to-any-output model. Feed it images, text, video, audio, or any combination, and it generates or edits video through conversation. Multi-turn editing keeps scenes consistent across back-and-forth iterations, and it applies real-world physics to generated content. Available in the Gemini app, Google Flow, and YouTube Shorts.

Multi-agent orchestration comes to Warp Oz
Warp just shipped multi-agent orchestration in Oz with support for Claude Code, Codex, and the Warp Agent. Use /orchestrate to delegate complex tasks across a team of agents running locally or in the cloud. If you're already in the Warp terminal, this makes it your control plane for parallel agent work.

Google Antigravity with Gemini 3.5 Flash now in your Terminal
Google Antigravity just shipped a CLI written in Go, powered by Gemini 3.5 Flash, and built for async workflows where agents run tasks in the background and report back when done. It shares the same tool and app server as Antigravity 2.0, so anything you build on the platform also works inside Google Search, where Antigravity powers the new agentic coding features: custom generative UIs, dashboards, and "mini apps" spun up from natural language.

Google Search gets its biggest overhaul in 25 years
The search box itself is being rebuilt: AI-powered, dynamically expanding, with multimodal inputs (text, images, files, videos, even Chrome tabs). New "search agents" will monitor the web 24/7 for specific criteria like apartment listings or sneaker drops, and agentic booking lets you complete local service bookings right from Search. Launching for Google AI Pro and Ultra subscribers this summer.

Tools of the Trade

1. Hallmark: Design skill by Hassan El Mghari that encodes anti-slop rules into Claude Code, Cursor, and Codex. Has four modes: build (generates pages that refuse to repeat the same structure twice), study (extracts a design's DNA from a URL or screenshot without copying pixels), audit (scores existing pages against its anti-pattern catalogue), and redesign (same content, deliberately different bones).

2. CodeGraph: Pre-indexed code knowledge graph for Claude Code, Codex, Cursor, and OpenCode that cuts tool calls by 92% and speeds up tasks by 71%. 100% local, MIT-licensed.

3. AgentMemory: Persistent memory MCP server for coding agents with 4-tier consolidation inspired by how the brain organizes memory during sleep. Works with every major coding agent.

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 😉 

I was looking at today’s updates and kept coming back to the Vercel one.

A programming language built with AI agents in mind sounds a little ridiculous at first. Like, do agents really need their own language now?

But then you look at the rest of today’s news: Garry Tan’s knowledge brain for his personal agents, Codex on mobile, and Peter Steinberger’s $1.3M monthly token spend.

Suddenly, it feels less ridiculous.

If agents are going to do real work, people are going to build weird new infrastructure around them. Some of it will be overkill. Some of it will probably become the new normal.

Today’s top AI Highlights:

1. Vercel built a programming language for AI agents

2. Garry Tan open-sourced the brain running his AI agents

3. LiteLLM launches sandboxes for agent fleets

4. Peter Steinberger spent $1.3M in OpenAI tokens in 30 days

5. Codex crossed 4M weekly users and landed on mobile

& 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

Garry Tan Open-Sources the AI Brain That Runs His Life

Garry Tan’s gstack made your AI agent ship code like a sprint team. Now, he open-sourced the knowledge system that powers his personal AI agents.

GBrain is not a notes app or a RAG pipeline. It's a structured, self-maintaining knowledge brain that currently holds 17,000+ pages, tracks 4,000+ people, and runs 21 autonomous cron jobs. Garry built it in 12 days.

The core idea is great: instead of re-deriving knowledge from scratch every query (like RAG does), GBrain pre-computes and maintains a "compiled truth" for every entity. Your agent gets richer context every time, and the whole thing compounds daily as it ingests meetings, emails, and calls. You wake up, and the brain is smarter than when you went to bed.

Key Highlights:

1. MECE knowledge structure - Everything is organized into clean categories: people, companies, deals, meetings, projects, concepts, originals, and media. Each page has a compiled summary on top and an append-only evidence trail below.

2. Self-wiring graph - Every page-write automatically extracts entity references and creates typed links (attended, works_at, invested_in) with zero LLM calls. Ask "who works at Acme AI?" and get answers vector search alone can't reach.

3. 34 built-in skills - From signal detection to content ingestion to research synthesis. Intelligence lives in markdown skill files, not the runtime. This is how Garry's agents know how to do things, not just remember things.

4. Auto-enrichment tiers - Mention someone once, they get a stub. Three mentions triggers web enrichment. Meet them in person or mention them 8+ times, and the full research pipeline kicks in. The brain decides how much attention someone deserves.

5. Usage - Works as a standalone CLI, an MCP server for Claude Code and Cursor, or a one-click deploy on OpenClaw or Railway. Check it out at github.com/garrytan/gbrain.

Vercel Built a Programming Language for AI Agents

Programming languages were designed for humans and then retrofitted for AI. Chris Tate from Vercel just changed that.

Zero is a new systems language where AI agents are first-class users of the entire toolchain. Compiler errors come back as structured JSON with stable error codes and fix suggestions that agents can parse and act on programmatically.

Think of it as a language where the compiler talks to your agent the same way a senior engineer talks to a junior one: here's what's wrong, here's the error code, here's exactly how to fix it.

Still experimental, but the idea is genuinely novel. And the fact that it's coming from Vercel, not a random weekend project, means there's real conviction behind it.

Key Highlights:

1. Structured diagnostics - Every compiler error returns JSON with stable codes, line locations, and repair metadata. No more regex-parsing error messages. Agents can read errors and fix code without scraping human-readable text.

2. Tiny output footprint - Compiles down to extremely small native binaries with no garbage collector, event loop, and hidden runtime overhead. Think CLI tools and serverless functions.

3. Full CLI toolchain - One command handles check, build, run, test, format, inspect, dependency graphs, and docs. Everything an agent needs in one place, all machine-readable output.

4. Human-readable too - Despite being agent-first, the syntax is clean and readable. File extension is .0, which is a fun touch.

5. Try it now - Zero is open-source (Apache 2.0) from Vercel. Check it out on GitHub and zerolang.ai.

LiteLLM Launches an Agent Platform with K8s Sandboxes

The team behind LiteLLM just shipped something bigger: a full platform for running fleets of coding agents in isolated Kubernetes sandboxes.

Each agent session gets its own fresh pod. Your real API keys never touch agent code.

A great feature is the credential vault. Agents only see stub tokens, and the platform transparently swaps in real secrets on every outbound connection.

If you're scaling from one coding agent to a team of them, this makes it super safe.

Key Highlights:

1. Agent-agnostic sandboxes - First-class support for Claude Code, Codex, and Hermes agents, all running in isolated pods that persist for 24 hours after you detach.

2. Credential vault - Agents never see your real API keys. The vault injects real secrets transparently on outbound connections, so a rogue agent can't leak anything. This alone is worth the setup.

3. Terminal-first workflow - The CLI lets you open a sandbox, attach your terminal, do your work, and Ctrl-D to detach. Simple and clean.

4. Full developer API - Create agents, open sessions, send messages, and read replies, all via REST. Build your own orchestration on top.

5. Open source and self-hostable - MIT licensed with local dev support and a production deploy path on AWS. Check it out at github.com/BerriAI/litellm-agent-platform.

Quick Bites

Peter Steinberger spent $1.3M in API tokens in 30 days
Peter Steinberger, creator of OpenClaw and now an OpenAI employee, casually revealed he burned through $1.3M worth of API tokens in a single month. That's roughly $20K per day, mostly on GPT-5.5 powering agents that manage the OpenClaw repo. Yes, he almost certainly has unlimited access as an OpenAI employee, so this isn't out of pocket. The number is wild, but the useful part is what it says about agent economics. Once agents run continuously, token spend becomes infrastructure, not just API usage

Codex hits 4M+ weekly users, now on Mobile
OpenAI's coding agent Codex just crossed 4 million weekly active users and is now available on iOS and Android through the ChatGPT app. You can kick off coding tasks, review diffs, and approve PRs from your phone. The "desk-only" constraint for AI-assisted coding is officially gone. 4M WAU also makes it one of the most widely adopted coding agents by a wide margin.

AI model built for deterministic dev tasks
Interfaze is a new model architecture that takes a fundamentally different approach. Instead of one autoregressive model doing everything, it breaks tasks into deterministic sub-steps like OCR, web search, classification, extraction, and then orchestrates purpose-built models for each. The result is structured output accuracy that beats GPT-5.4-Mini and matches Gemini-3-Flash. It's OpenAI SDK-compatible, comes with built-in web search from its own crawler, and runs tasks like audio transcription (1h 35m podcast in ~50 seconds) and document OCR natively. Free tier available at interfaze.ai.

ChatGPT now wants to manage your personal finance
OpenAI launched a personal finance experience in ChatGPT for Pro users in the U.S. Connect your bank accounts via Plaid, and ChatGPT gives you a spending dashboard, subscription tracker, and financial guidance grounded in your transaction data. The before/after examples are genuinely compelling, going from generic "save more money" advice vs. "cap dining at $450/month based on your Feb-May spend." OpenAI has also partnered with Intuit that signals the next step: actionable finance, like applying for credit cards and scheduling tax appointments directly from chat.

Tools of the Trade

1. Clawpatch: Code review for agent-written code. It maps a repo into semantic slices like routes, commands, packages, and tests, then reviews bounded contexts instead of isolated files.

2. Semble: Code search built specifically for AI coding agents. Instead of dumping entire files into context, Semble indexes your repo and returns only the relevant snippets, using 98% fewer tokens than grep-and-read. Drop-in MCP server for Claude Code, Codex, and Cursor.

3. Learning Opportunities: A Claude Code and Codex plugin that pauses after significant coding work and offers short, evidence-based learning exercises. The idea: if an AI agent writes your code, you should still understand what it did and why. Turns AI-assisted coding into actual skill building.

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 😉 

/goal is not a feature. It is a primitive.

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.

So I now have a builder, a reviewer, and an orchestrator that all accept the same instruction format, even though they share nothing else.

If you've only seen /goal used as a fancier prompt, you've missed what it changes.

What /goal actually is

A regular prompt asks an agent for the next response. You read what comes back, decide if it's right, and push the agent forward to the next step. You're steering every turn.

/goal flips that. You write down what "done" looks like, submit it once, and the agent works toward it until it gets there. Here's a real one:

/goal Build the app described in SPEC.md. Done means tests pass, build passes, README is accurate, and git status only shows relevant project files.

The goal stays active until it's achieved, paused, blocked, cleared, or it runs out of budget.

This is different from putting the word "goal" inside a normal one-shot command. If you write codex exec 'goal: build the app', that's still a prompt with a label. The real primitive lives inside an interactive worker session. You launch the CLI, you submit /goal, and you walk away.

The shift is from prompting (you driving) to assigning (the agent driving toward a target you defined).

The three tools that currently speak /goal

The three tools accepting /goal aren't all the same kind of thing, so it's worth being specific.

Codex is OpenAI's coding CLI. Strong at implementation, especially when given a clear spec. /goal is how you give it that spec.

Claude Code is Anthropic's coding CLI. Strong at the inverse: finding what's wrong with code that looks right. Spec compliance, safety issues, error states, security holes. /goal is how you point it at code and ask for a review.

Hermes Agent is a different kind of tool entirely. Not a coding worker, but an orchestrator that coordinates work between coding workers like the two above. /goal is how Hermes hands off tasks to whichever tool is right for the job, and also how I tell Hermes what I want in the first place.

What matters isn't that any one of them shipped /goal. It's that three different teams converged on the same primitive, and that convergence is what makes it possible to compose them.

Setting things up

The first time I needed Codex and Claude Code on the Mac Mini that runs Hermes, I didn't install them by hand. I sent Hermes a message asking it to install both and log me in. It handled the rest.

That's the workflow now. You don't type install commands. Setup is just another goal.

If you don't have an orchestrator running yet, the install pages for Codex and Claude Code are easy enough to follow. But once you do, you shouldn't set up another tool by hand. The point of having an orchestrator is that mechanical work stops being yours.

What Hermes adds on top of /goal

A raw /goal is useful on its own. But it leaves you with a coordination problem.

If Codex is running in one terminal and Claude Code is running in another, you have to remember which process is doing what. You have to check logs. You have to manually pass review findings from one tool to the other.

Hermes turns those loose runs into a workflow:

1. You message Hermes (in my case, over Telegram from my phone)

2. Hermes creates goal cards on a Kanban board

3. Hermes picks the right worker for each card

4. The worker runs the goal in the background

5. The card stores the process id, PID, repo, and done criteria

6. When the build is ready, Hermes hands the repo to the reviewer

7. If the review blocks, Hermes sends the findings back as a fix goal

8. Hermes verifies the final output by inspecting the filesystem, tests, build, and git state

The board is what /goal becomes when there's an orchestrator on top of it. Every goal has a card, every card has a status, every handoff leaves a trail. Instead of hunting through terminals, you watch the work move across columns on your phone.

The three roles

The tools change. The roles don't.

Orchestrator. Owns the control loop. Task decomposition, worker selection, Kanban cards, background processes, dependencies, final verification, the user-facing summary. In my setup, Hermes.

Builder. Takes a spec and produces working code. Implementation is the bottleneck this role solves. Codex tends to be strong here.

Reviewer. Reads what the builder produced and finds what's wrong with it. Correctness is the bottleneck. Claude Code tends to be strong here.

A real run, end to end

I gave Hermes agent a goal to do this:

/goal Build a CLI tool that finds X mentions of me and pings me when something blows up.

Hermes broke the request into six cards.

Twitter tweet

Card 1: Spec. Hermes wrote SPEC.md itself, capturing the stack, repo path, read-only constraints, mock mode requirements, tests, and verification commands. Owned by the PM role.

Card 2: Codex builds. Codex ran /goal against SPEC.md. It created the project files, implemented the UI and backend, added tests, and got the app to a passing state. About 15 minutes. When it finished, npm test passed, npm run build passed, and git status showed only relevant new files.

Card 3: Claude Code reviews. Claude Code ran /goal to review what Codex built. Checked spec compliance, read-only safety, API key handling, error states, tests, UI usefulness, bugs, and security issues. Result: PASS, no blocking issues.

Card 4: Codex fix loop. Skipped, because the review passed. The card still matters when skipped. It shows Hermes can model conditional work. If Claude Code had blocked, Hermes would have handed the findings back to Codex as a new /goal.

Card 5: Claude Code final verification. Skipped for the same reason.

Card 6: Hermes final summary. Working app at the local path, UI and API both verified in mock mode. Codex built it with /goal. Claude Code reviewed it with /goal and returned PASS.

All of that came from one message. Three different tools did the actual work, but I only ever talked to Hermes.

The verification rule

Hermes never trusted Codex's self-report. After Codex marked the build done, Hermes ran the commands itself:

npm test         # 17 tests passed
npm run build    # vite build passed

The verifier is what makes a /goal a contract instead of a promise. Don't trust the worker's self-report as final. Trust the verifier.

Coding agents are confident. They'll tell you the build passes when the build was never run. They'll tell you tests pass when they wrote tests that never executed. The verifier closes that gap.

Without verification, /goal is just a fancier prompt. With verification, it becomes a contract.

Running multiple goals

You can run multiple /goals in parallel, but you can't point multiple coding workers at the same files without thinking about it first.

My default is one main builder per repo. If I want parallelism, I add it across clear boundaries. Different repos, different branches, git worktrees, separate packages, docs vs code, tests vs implementation. Anywhere two workers can't step on each other.

The bad pattern is three workers all editing the same file in the same repo. You get conflicts, partial overwrites, and one worker silently undoing another's work.

The better pattern is one writer at a time on any given file. Builder writes, reviewer only reads, fix goals stay scoped to the fix. Or run three builders in three worktrees on three competing approaches and let the orchestrator pick the best one.

The board is what makes this practical. Without it, parallel background workers become terminal chaos.

What changes for me

The useful framing here is not "I can run agents in the background."

It's that one message turns into a pipeline across three different coding tools, and I watch the whole thing move across one board.

You stop sitting in a terminal waiting for one agent to finish, and start managing a queue of work with visible state.

If Codex and Claude Code had each invented their own job-handoff format, no orchestrator could route between them. The board is impressive, but the primitive makes the board even more useful.

The workers can change, but the primitive stays the same. The next coding tool that adopts /goal will join this pipeline without me changing anything. I'll just route work to it.

That's what good primitives do.

For more such cool tips and interesting ideas around Hermes, OpenClaw, Claude Code, Codex and other 24/7 agent teams.

Follow → @Saboo_Shubham_

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. OpenClaw creator open-sourced a native Mac automation tool

2. Run DeepSeek V4 Flash locally on a 128GB Mac

3. OpenAI enters serious cyber defense with Daybreak

4. /goal in Codex CLI, Hermes Agent, and Claude Code

5. Let agents pay for your API in ~3 lines of code

& so much more!

Read time: 3 mins

AI Tutorial

Build a Multimodal Agentic RAG App with Gemini Embedding 2 and Google ADK

In this tutorial, you'll build a fully-working multimodal agentic RAG app where text, URLs, PDFs, images, audio, and video all share a single 768-dimension embedding space, and a small Google Agent Development Kit (ADK) coordinator turns the retrieved evidence into a grounded, cited answer.

The two pieces doing the heavy lifting are Gemini Embedding 2, which embeds every modality into the same vector space, and Google ADK, which wraps the retrieval call in an agent that inspects the workspace, calls the retrieval tool, and writes the answer.

You'll see exactly how those two pieces compose without any extra orchestration framework.

Build a Multimodal Agentic RAG App with Gemini Embedding 2 and Google ADK

(100% open source)

We share hands-on tutorials like this every week, designed 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 newsletter on your social channels and tag Unwind AI (X, LinkedIn, Threads) to support us!

Latest Developments

OpenClaw creator open-sourced a native Mac automation tool

Still using computer use agents doing screenshot → click → reason → hallucinate → repeat?

Peter Steinberger open-sourced Peekaboo, a MacOS-native toolkit that hands agents the accessibility tree directly, so clicks land on real elements with IDs, not pixel coordinates that drift every time the window moves. 

Beyond click and type, it covers the stuff every other agent fails at, like Spaces switching, Dock right-clicks, menu bar extras, file dialogs, drag-to-Trash.

Use it with Claude Code, Codex, OpenClaw, Hermes Agent, or which agent harness you like, via CLI and MCP server. Bring any model like Claude, GPT-5.1, Grok 4-fast, or Ollama for fully local runs. MIT-licensed.

Key Highlights:

1. Native, not virtualized: Runs as a real macOS process with Screen Recording + Accessibility permissions. It can drive any app you can, including ones that block automation inside browsers or VMs.

2. Structured menu discovery: peekaboo menu returns the full menu tree as JSON, so agents navigate "File → Export → PDF…" by name instead of pattern-matching on screenshots.

3. Multi-screen and multi-Space aware: First-class support for moving windows between Spaces, switching desktops, and targeting elements on specific displays.

4. Drop into OpenClaw: Lives in the repo as skills/peekaboo-cli, so you can install as an OpenClaw skill alongside the 5,400+ others.

Voxtral TTS: Outperforms ElevenLabs on naturalness

When it comes to voice agents, naturalness is a key factor. Voxtral TTS outperforms ElevenLabs Flash v2.5 on naturalness and matches ElevenLabs v3 quality with emotion-steering support. Lightweight at 4B parameters, built for production.

Key Highlights:

1. Wins 58.3% of flagship voice preference tests: In side-by-side human evaluations against ElevenLabs Flash v2.5, Voxtral TTS wins on naturalness across flagship voices and 68.4% on voice customization.

2. Emotion-aware output: Contextual understanding (neutral, happy, sarcastic, and more) determines whether output sounds considered or robotic.

3. 70ms model latency, ~9.7x real-time factor: Streams natively and integrates into any existing STT and LLM stack.

4. Voice cloning from 3 seconds of audio: Adapts to tone, personality, rhythm, and intonation. Zero-shot, no fine-tuning required.

5. Open weights under CC BY NC 4.0: Deploy on your own infrastructure, extend to your own voice library.

Try it now!

Run DeepSeek V4 Flash locally on a 128GB Mac

The creator of Redis just built a dedicated inference engine for a quasi-frontier model. It might be the most opinionated piece of AI infrastructure released this year.

Salvatore Sanfilippo (antirez) released DwarfStar4, a purpose-built C + Metal engine that runs DeepSeek V4 Flash, a 284B parameter open-source model with a 1M token context window, locally on a 128GB MacBook at ~27 tokens/second.

No generic runtime or framework. Just raw C + Metal doing one thing really well. The engine uses an asymmetric 2-bit quantization that fits the entire model in ~81GB, ships with a disk-based KV cache that's a lifesaver for agent workflows, and built-in APIs that plug straight into agents like OpenClaw, Hermes, Claude Code, Opencode, and Pi.

Key Highlights:

1. One Model, Maximum Optimization: DS4 isn't a generic model runner. It's a dedicated engine built exclusively for DeepSeek V4 Flash, squeezing out performance that general-purpose tools can't match.

2. Runs on a MacBook: A specialized 2-bit quantization compresses the 284B model to ~81GB while keeping code generation and tool calling quality intact, making it genuinely usable on 128GB Macs.

3. Disk KV Cache for Agents: Saves session state to your SSD so agent clients that resend large system prompts every request can skip the expensive prefill after the first run. That’s a massive time saver.

4. Agent-Ready Out of the Box: Ships with OpenAI and Anthropic-compatible server APIs plus ready-to-use configs for Claude Code, opencode, and Pi.

Quick Bites

OpenAI enters serious cyber defense with Daybreak
OpenAI just shipped Daybreak, a cyber defense stack built on GPT-5.5 and Codex Security.

iykyk

The idea is Codex ingests your repo, builds a threat model specific to your codebase, then maps attack paths and validates real vulnerabilities in sandboxed environments. It generates patches, runs them, and sends audit-ready evidence back into your existing security stack. Here’s how the access will work for now: standard GPT-5.5 stays general-purpose, Trusted Access unlocks for verified defenders doing vuln triage and malware analysis, and GPT-5.5-Cyber is for authorized red teaming, pen testing, and controlled validation.

Thinking Machines show what they’re building with $2B funding
Thinking Machines finally demoed what they’re working on: "interaction models." At first glance, it feels a lot like the GPT-4o demo from 2 years ago: real-time, audio-video-text. The interesting part is underneath though: a 276B MoE “interaction model” (12B active, 0.40s latency) that handles the live conversation, and a separate background model runs reasoning, searches, and tool calls mid-chat, then feeds results back in. Full-duplex isn't new (hi Moshi from Kyutai Labs), but the architectural design is interesting, and the early benchmarks on latency and quality are solid.

Claude Agents can now dream between sessions
Anthropic's Claude Managed Agents (their hosted agent runtime, launched last month) got a solid update: dreaming, outcomes, and multi-agent orchestration. Dreaming is the one worth paying attention to! It reviews past agent sessions between runs, surfaces recurring mistakes and workflow patterns, and folds them back into memory automatically. Outcomes lets you define a success rubric evaluated by a separate grader in its own context window, looping the agent back until output clears the bar. Multi-agent orchestration does what you'd expect — lead agent delegates to specialist subagents, each with their own model and tools, running in parallel.

What the Hermes Agent community is actually building
If you’re still wondering what people are using Hermes Agent for, here’s a wall of 200+ of them to inspire you! The team used Hermes Agent itself to scrape the entire internet for these usecases and added them to their docs. And if you've found an interesting use case, you can submit your own!

/goal in Codex CLI, Hermes Agent, and Claude Code
ICYMI and have been manually re-prompting your coding agents with "keep going," that's now a solved problem across the board. /goal gives the agent a durable objective with a clear done-condition. It keeps looping - planning, editing, running, and verifying until that condition is actually met or you tell it to stop. Codex CLI shipped it first, Hermes Agent picked it up in v0.13.0, and Claude Code now has its own native version. And here’s an interesting workflow we discovered: use Hermes Agent as an orchestration layer to fire /goal across Codex CLI and Claude Code simultaneously, and track all the running objectives on Hermes's Kanban board.

Tools of the Trade

1. Sangria: An open-source SDK that lets you put a paywall on any API endpoint so AI agents can pay per request automatically via the x402 protocol and USDC on Base. Drops into Express/Fastify/Hono/FastAPI with minimal code.

2. agent-harness-kit: An open-source TypeScript CLI that scaffolds a structured multi-agent workflow into any codebase. One command sets up multiple agents (lead, explorer, builder, reviewer), a SQLite task backlog, and a health gate that runs before any agent can start or close work. It's provider-agnostic (Claude Code, OpenCode) and ships its own local MCP server.

3. /orchestrate: Skill that decomposes large tasks into a tree of parallel cloud agents: planners, workers, and verifiers. It runs on the Cursor SDK's cloud runtime, so each agent gets an isolated VM, and the whole tree reconciles back through git and structured handoffs.

4. Awesome LLM Apps - 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 😉 

If you have built a RAG app before, you know how quickly the "just retrieve the right chunk" problem fragments the moment your sources stop being plain text. Product PDFs, UI screenshots, recorded calls, demo videos, and support notes all carry the answer your user is asking for, but each lives in its own embedding silo.

Stitching them together usually means three pipelines, two vector stores, and a glue layer you regret pretty soon.

In this tutorial, you'll build a fully-working multimodal agentic RAG app where text, URLs, PDFs, images, audio, and video all share a single 768-dimension embedding space, and a small Google Agent Development Kit (ADK) coordinator turns the retrieved evidence into a grounded, cited answer.

The two pieces doing the heavy lifting are Gemini Embedding 2, which embeds every modality into the same vector space, and Google ADK, which wraps the retrieval call in an agent that inspects the workspace, calls the retrieval tool, and writes the answer.

You'll see exactly how those two pieces compose without any extra orchestration framework.

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

What We’re Building

A multimodal Agentic RAG demo where you can drop in any file or URL and ask questions across the whole index. The same retrieval packet powers both the answer and the citation panel, so the UI never disagrees with the model.

Key features:

• Truly multimodal index — text, URLs, PDFs, images, audio, and video all live in one cosine-similarity space.

• Gemini Embedding 2 with task prefixes — separate prefixes for documents and queries to improve retrieval quality.

• Google ADK agent — coordinates inspect_embedding_space and retrieve_relevant_context tools, then synthesizes a grounded answer.

• Single retrieval, two consumers — /ask retrieves once, then passes the same packet to the agent and to the UI.

• 3D PCA embedding view — every source is one point; ask a question and the query and cited sources light up in the same projection.

• SSRF-safe URL ingestion — private and loopback IPs blocked unless you opt in.

How It Works

End-to-end, one question flows like this:

1. You add sources. Each source is chunked (text/URL) or uploaded once (PDF/image/audio/video). Every chunk gets a Gemini Embedding 2 vector with the task: retrieval document prefix. Files get a media vector blended with a text annotation vector, so titles still help retrieval.

2. You ask a question. /ask embeds the query with the task: question answering | query prefix, scores every chunk by cosine similarity, keeps the best chunk per source, takes the top k, and projects everything into 3D using power-iteration PCA.

3. The agent runs. _run_adk_agent builds a per-request agent whose retrieve_relevant_context tool is a closure over the already-computed retrieval packet. The agent calls inspect_embedding_space, then "calls" the retrieval tool, then writes a grounded answer with no inline citation IDs.

4. The UI renders. The frontend shows the answer text, the citation panel (built from the same matches), the agent trace, and the updated 3D view with the query point and highlighted sources.

The architectural insight is the single-retrieval contract: one query embedding, one ranked list of matches, two consumers (the agent and the UI). That's what keeps citations honest.

Prerequisites

Before we begin, make sure you have the following:

1. Python installed on your machine (version 3.12 is recommended)

2. Your Gemini API key for using Gemini Embedding 2

3. A code editor of your choice

4. Basic Python and FastAPI familiarity

Code Walkthrough

Setting Up the Environment

First, let's get our development environment ready:

1. Clone the GitHub repository:

git clone https://github.com/Shubhamsaboo/awesome-llm-apps.git

🌟 Don't forget to star the opensource repo to show your support.

2. Go to the multimodal_agentic_rag folder:

cd rag_tutorials/multimodal_agentic_rag/backend

3. Install the required dependencies:

pip install -r requirements.txt

4. Grab your Gemini API key from Google AI Studio and set it in your current session:

export GOOGLE_API_KEY="your-google-ai-studio-key"

Creating the App

Project structure:

rag_tutorials/multimodal_agentic_rag/
|-- README.md
|-- assets/
|   `-- multimodal-agentic-rag-architecture.png
|-- backend/
|   |-- app_state.py
|   |-- rag_store.py
|   |-- requirements.txt
|   |-- server.py
|   `-- agentic_rag_agent/
|       |-- __init__.py
|       `-- agent.py
`-- frontend/
    |-- index.html
    |-- package.json
    |-- src/
    |   |-- App.tsx
    |   |-- main.tsx
    |   `-- styles.css
    |-- tsconfig.json
    `-- vite.config.ts

We’ll skip the frontend code walkthrough and focus on the backend architecture.

1. The Shared Store (app_state.py)

A single line keeps the in-memory index addressable from both FastAPI and the ADK tools:

from rag_store import MultimodalRagStore

RAG_STORE = MultimodalRagStore()

Both server.py and the ADK tool functions import RAG_STORE from here, so the agent always sees the same sources you uploaded through the UI.

2. The Multimodal Store (rag_store.py)

This is where most of the interesting code lives. A few constants set the contract:

EMBED_MODEL = "gemini-embedding-2"
DEFAULT_DIMENSIONS = 768
CHUNK_WORDS = 170
CHUNK_OVERLAP = 35
INLINE_MEDIA_LIMIT_BYTES = 18 * 1024 * 1024

We chunk text into roughly 170-word windows with 35-word overlap and embed each chunk separately. Anything bigger than ~18 MB or any audio/video file goes through the Gemini File API instead of inline bytes.

Embedding text with task prefixes

Gemini Embedding 2 supports task prefixes — small instructions like "task: retrieval document" or "task: question answering | query" that tell the model how this content will be used. Documents and queries get different prefixes, which measurably improves retrieval:

def _embed_text(self, text: str, task_prefix: str) -> list[float]:
    content = f"{task_prefix}: {text}"
    client = self._require_client()

    result = client.models.embed_content(
        model=EMBED_MODEL,
        contents=[content],
        config=types.EmbedContentConfig(output_dimensionality=self.dimensions),
    )
    return result.embeddings[0].values

The interesting bit is output_dimensionality=768: Gemini Embedding 2 supports truncating to smaller, latency-friendlier vectors right at the API call, so you don't have to pay for storage or cosine math on the full embedding width.

Embedding files (PDFs, images, audio, video)

Multimodal is where Gemini Embedding 2 earns its keep. Small images and PDFs go inline; large files and all media go through the File API:

def _embed_file(self, data, mime_type, title, notes):
    client = self._require_client()

    use_file_api = (
        len(data) > INLINE_MEDIA_LIMIT_BYTES
        or mime_type.startswith("video/")
        or mime_type.startswith("audio/")
    )
    if use_file_api:
        return self._embed_uploaded_file(data, mime_type, title), "gemini-file-api"

    part = types.Part.from_bytes(data=data, mime_type=mime_type)
    result = client.models.embed_content(
        model=EMBED_MODEL,
        contents=[part],
        config=types.EmbedContentConfig(output_dimensionality=self.dimensions),
    )
    return result.embeddings[0].values, "gemini-inline"

The File API path uploads the file, polls until its state is ACTIVE/SUCCEEDED, embeds via Part.from_uri, and then deletes the uploaded file in a finally block — important so you don't leak storage on every upload.

To make a PDF or image still findable by its title (e.g., "the launch deck"), we blend the media vector with a text vector of the title plus user-provided notes:

media_vector, embedding_path = self._embed_file(...)
annotation_vector = self._embed_text(f"{title}. {notes}", "task: retrieval document")
vector = _blend_vectors(media_vector, annotation_vector)  # 68% media / 32% text

This is a small but very effective trick: native multimodal embeddings are great at semantic content, but humans often search by the label they gave the file.

Search: cosine similarity per chunk, deduplicated per source

def search(self, query: str, top_k: int = 6) -> dict[str, Any]:
    query_vector = self._embed_text(query, "task: question answering | query")
    source_vectors = self._source_vectors()
    projections = self._pca_projection({**source_vectors, query_id: query_vector})
    ...
    for chunk in self.chunks:
        score = round(_cosine(query_vector, chunk.vector), 4)
        current = source_matches.get(chunk.source_id)
        if not current or score > current["score"]:
            source_matches[chunk.source_id] = { ... }
    matches = sorted(source_matches.values(), key=lambda m: m["score"], reverse=True)[:top_k]

Three subtle decisions here: we score every chunk but keep only the best chunk per source, we project source vectors and the query vector together so the 3D view shares the same basis, and we return a fully-formed space snapshot so the frontend never has to ask twice.

PCA projection in pure Python

The _pca_projection method runs power iteration to find the top three principal components and projects every vector into 3D — no NumPy, no scikit-learn. That keeps the dependency list short and the projection deterministic per request.

The retrieval payload

The agent doesn't see raw chunks; it sees a clean, model-friendly payload:

def retrieval_payload(self, results):
    return {
        "provider": self.embedding_provider,
        "matches": [
            {
                "citation": m["id"],
                "source": m["title"],
                "modality": m["modality"],
                "similarity": m["score"],
                "evidence": m["text"],
            }
            for m in results["matches"]
        ],
    }

This is the exact same packet that /ask returns to the frontend, which is how we guarantee the answer and the citation panel never drift.

3. The ADK Agent (agentic_rag_agent/agent.py)

A short, sharp ADK agent with two tools and a focused instruction:

def retrieve_relevant_context(query: str, top_k: int = 5) -> dict:
    """Retrieve the most relevant multimodal source evidence for a user question."""
    return RAG_STORE.retrieval_tool(query=query, top_k=top_k)


def inspect_embedding_space() -> dict:
    """Inspect current sources, modalities, dimensions, and embedding provider."""
    return RAG_STORE.space_tool()


def build_agent(retrieval_tool=retrieve_relevant_context) -> Agent:
    return Agent(
        name="multimodal_agentic_rag_agent",
        model="gemini-3-flash-preview",
        description="Agentic RAG coordinator for a multimodal Gemini Embedding 2 workspace.",
        instruction="""
You are the Google ADK coordinator for a multimodal agentic RAG workspace.

For every user question:
1. Use inspect_embedding_space to understand the current workspace.
2. Use retrieve_relevant_context with the user's question before answering.
3. Ground the answer in the retrieved evidence. Do not invent facts...
4. Do not include raw citation ids, source ids, bracket citations...
5. Start with a clear direct answer in 2-3 sentences.
6. If helpful, add a short "Key points:" section with simple hyphen bullets.
""",
        tools=[inspect_embedding_space, retrieval_tool],
        generate_content_config=genai_types.GenerateContentConfig(
            temperature=0.25,
            max_output_tokens=900,
        ),
    )

build_agent accepts an injectable retrieval_tool. That's how server.py swaps in a closure that returns the already-computed retrieval packet, instead of letting the agent embed the query a second time.

4. The FastAPI Server (server.py)

The endpoint surface is small and predictable:

The key piece is /ask. It retrieves once, builds a clean payload, and injects a closure into the agent so it can't redo the embedding:

@app.post("/ask")
async def ask(req: AskRequest):
    retrieval = await run_in_threadpool(RAG_STORE.search, req.question, req.top_k)
    retrieval_payload = RAG_STORE.retrieval_payload(retrieval)
    answer = await _run_adk_agent(req.question, retrieval_payload)
    trace = [
        {"agent": "space_inspector",   "status": "complete", "detail": ...},
        {"agent": "retrieval_tool",    "status": "complete", "detail": ...},
        {"agent": "answer_synthesizer","status": "complete", "detail": ...},
    ]
    return {
        "answer": answer,
        "matches": retrieval["matches"],
        "query_point": retrieval["query_point"],
        "trace": trace,
        "space": retrieval["space"],
    }

And the closure injection inside _run_adk_agent:

async def _run_adk_agent(question: str, retrieval: dict[str, Any]) -> str:
    def retrieve_relevant_context(query: str, top_k: int = 6) -> dict:
        """Return the exact retrieval packet already embedded for this request."""
        return retrieval

    request_agent = build_agent(retrieve_relevant_context)
    request_runner = Runner(agent=request_agent, app_name=APP_NAME, session_service=session_service)
    session = await session_service.create_session(app_name=APP_NAME, user_id=USER_ID)
    content = genai_types.Content(
        role="user",
        parts=[genai_types.Part(text=f"Question: {question}\nUse the retrieval tool result for this exact question.")],
    )
    final_text = ""
    async for event in request_runner.run_async(user_id=USER_ID, session_id=session.id, new_message=content):
        text = _event_text(event)
        if text:
            final_text = text
    return final_text

The agent thinks it's calling a real retrieval tool. It is — the tool just returns a cached result. This is a clean way to keep agent semantics while skipping a redundant embedding round-trip.

A couple of safety details worth highlighting:

• SSRF protection: _validate_fetch_url rejects non-HTTP schemes and resolves the hostname; if any returned IP is private, loopback, link-local, or reserved, ingestion fails. Set ALLOW_PRIVATE_URLS=true only when you really need it.

• Threadpool offloading: every blocking call (text chunking, file reads, search, PCA) runs in run_in_threadpool so the FastAPI event loop stays responsive.

• Configurable CORS: ALLOWED_ORIGINS is read from the env, defaulting to the Vite dev server.

5. The Frontend (very brief)

The frontend is a single React/Vite app (frontend/src/App.tsx) that wraps three panels: a source manager for adding text/URLs/files, a Q&A panel that calls /ask and renders the answer plus a separate citations list, and a 3D embedding view built on Three.js that uses the projection coordinates returned by the backend. Every source is one colored point (color encodes modality), and after a question the query point and the cited sources are highlighted in the same PCA basis.

Running the App

With our code in place, it's time to launch the app.

Start the backend

python server.py

The backend listens on http://localhost:8897.

Start the frontend in a second terminal:

cd multimodal_agentic_rag/frontend
npm install
npm run dev -- --port 5177

If your backend lives on a different port, point the frontend at it:

VITE_API_URL=http://localhost:8897 npm run dev -- --port 5177

1. Add a few sources — try a paragraph of text, a public URL, a PDF, and an image.

2. Watch them appear as colored points in the embedding view.

3. Ask a question in the Q&A panel.

4. Inspect the answer, the cited sources, and the agent trace.

5. Notice the orange query point land near the sources the agent cites.

A quick health check from the terminal:

curl http://localhost:8897/health

Expected response shape on a fresh start (the store begins empty):

{
  "status": "ok",
  "adk": true,
  "setup_error": "",
  "sources": 0,
  "chunks": 0,
  "dimensions": 768,
  "provider": "gemini-embedding-2",
  "modalities": {},
  "chunk_modalities": {},
  "projection": "pca_3d"

Working Application Demo

Conclusion

You've now built a multimodal agentic RAG app that puts text, URLs, PDFs, images, audio, and video into a single Gemini Embedding 2 space, retrieves with cosine similarity over chunked vectors, and uses a tightly-scoped Google ADK agent to write grounded, citation-friendly answers, without a separate vector database, in a few hundred lines of Python.

A few directions worth exploring from here:

• Swap the in-memory store for a managed vector DB (pgvector, Qdrant, Vertex AI Vector Search) and persist the chunk metadata.

• Add re-ranking with a cross-encoder or a Gemini reranker between cosine retrieval and the agent.

• Background ingestion with a queue (Celery, RQ, or a simple async worker) so large videos don't block the API.

• Evals: wire a small eval set with question/answer pairs and track citation precision and answer faithfulness over changes.

• Auth + multi-tenancy so different users see different workspaces.

• Observability: log the retrieval packet alongside the final answer; the single-retrieval contract makes faithfulness audits straightforward.

Keep experimenting with different configurations and features to build more sophisticated AI applications.

We share hands-on 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. Attention Is All You Need - Just 1/1000th of It

2. Free web Search and Fetch, for every dev and AI agent

3. Stop RAG-ing, start Grepping your company knowledge

4. Make your Hermes Agent your video editor with one Skill

5. Extract a website’s complete design system with one command

& so much more!

Read time: 3 mins

AI Tutorial

Anatomy of Agent SKILLS

Your agent has a 200k token context window.

The 400 tokens of instructions it actually needs are buried under tool definitions, reference docs, and brand guides it never asked for. So it ignores them.

This is the most common reason agents fail in production. It's not a model problem or a framework problem.

In this blog, you'll learn the anatomy of Agent Skills: why the first two lines of SKILL.md are the most important writing you'll do, and how the LLM itself routes queries to the right skill without embeddings or retrieval layers.

Read on to learn the five parts that make skills work, then pick one workflow you do every week and ship your first skill today.

Anatomy of Agent SKILLS

Same agent, much less context

We share hands-on tutorials like this every week, designed 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 newsletter on your social channels and tag Unwind AI (X, LinkedIn, Threads) to support us!

Latest Developments

Attention Is All You Need - Just 1/1000th of It

12 million tokens of context in a single pass, and it does it at roughly 1/1000th the attention compute of current frontier models.

Meet SubQ, the first large language model built on a fully subquadratic sparse attention (SSA) architecture, where compute scales linearly with context length instead of quadratically.

Transformers compare every token to every other token, which means doubling input length quadruples the compute. SubQ's architecture focuses only on the token relationships that actually matter, making million-token workloads fast and cheap enough to be practical.

The model is entering private beta today with an API, a coding agent called SubQ Code, and a long-context search tool called SubQ Search.

Key Highlights:

1. Benchmark Performance: SubQ 1M-Preview scores 95% on RULER 128K and 81.8 on SWE-Bench Verified, putting it on par with or ahead of Opus 4.6 and Deepseek V4 Pro on both long-context accuracy and code tasks.

2. Speed & Efficiency: Its sparse attention runs 52x faster than FlashAttention at 1M tokens while requiring 63% less compute.

3. 5% Cost of Opus 4.7: Though the pricing is not out, the team claims it costs <5% Opus's cost at scale, with RULER 128K running for $8 vs ~$2,600. Take this with a grain of salt for now!

4. Private Beta: All three products (API, Code, Search) are available via early access at subq.ai.

Free web Search and Fetch, for every dev and AI agent

TinyFish just made their Web Search and Fetch endpoints free with generous rate limits. Forever. No credit card or “7-day” trial”. Just sign up and grab your API key.

Search returns structured JSON for agents. Fetch renders any URL in a real browser with full JavaScript, SPAs, anti-bot, all of it, strips the unnecessary content, and returns clean markdown.

Everything runs on TinyFish's own custom Chromium fleet. Owning the stack end-to-end makes their Search and Fetch both free and fast.

• Works with Claude Code, OpenClaw, Hermes Agent, Cursor, Codex, and any agent framework

• Available via API, MCP, Python + TypeScript SDKs, CLI, and Skills

• One API key. No credit card.

Grab your API key now!

Stop RAG-ing, start Grepping your company knowledge

Your company's best knowledge is rotting in Slack threads nobody will ever search again.

And no, RAG is not the solution. The index is always stale. The chunks land at the wrong boundaries.

Turns out, coding agents already cracked this. They don't search, they grep

Scout, an open-source context agent from Agno, borrows the trick and navigates your information sources live. It connects to Slack, Google Drive, Linear, MCP servers, and more, walking each source's native API at query time to assemble real answers with real citations.

As it works, it builds its own wiki and CRM. Say "Josh from Anthropic shared a paper on RLMs" and Scout files Josh as a contact, parses the paper into a wiki page, and links them together.

The whole thing is open-source, ready to fork and customize.

Key Highlights:

1. Context Providers: Instead of exposing dozens of API-specific tools to the main agent, Scout wraps each source behind a thin sub-agent layer. The main agent sees query_slack, not Slack's twelve endpoints, keeping context clean.

2. Navigation over search: Scout queries live APIs at request time, so a Slack message sent thirty seconds ago is immediately available, and citations always point to real, openable paths.

3. Self-building CRM and wiki: It populates a Postgres-backed CRM and a knowledge wiki as it learns. It even creates new database tables on demand.

4. Ready to clone and use: Ships with Docker Compose, connects to Agno's AgentOS for multi-user sessions and scheduled tasks, and plugs into Slack with full thread history. More connectors coming soon!

Quick Bites

Codex gets a Tamagotchi
OpenAI shipped pets for Codex. These are animated companions that double as a persistent status overlay for your coding agent. The pet visually maps to whether Codex is actively working, waiting for input, or flagging something for review. Think of it as the most adorable process monitor you never asked for.

Just another day of the Claude team shipping
Anthropic just dropped ten agent templates built specifically for finance work, like pitchbooks, KYC screening, month-end close, valuation checks, the whole grind. They plug into Cowork and Claude Code or run autonomously as Managed Agents, and they come wired to data sources like Moody's, Third Bridge, and S&P Capital IQ. Oh, and Claude now works inside Excel, PowerPoint, Word, and Outlook with context that follows you across apps — so yes, your comps model can become a deck without explaining everything twice. Install them as plugins in Cowork and Claude Code

Make your Hermes Agent your video editor with one Skill
Hermes Agents can now spin up full videos, courtesy HyperFrames Agent Skill by HeyGen. Just do $ hermes skills install hyperframes, and your agent becomes a video editor that treats HTML as the source of truth for video. Feed it an X post, a PDF, or a GitHub repo, and it'll script, animate with GSAP, lay captions over TTS narration, and render a finished MP4, all orchestrated end-to-end by the agent itself.

Tools of the Trade

1. Designlang: Extract any website's complete design system with one command. It reads the design system off the live DOM, and emits 17+ files — DTCG tokens, Tailwind config, shadcn theme, Figma variables, motion tokens, typed component anatomy, brand voice, page-intent labels, and a paste-ready prompt pack for v0 / Lovable / Cursor / Claude Artifacts.

2. Interact AI: Replaces your static website with an adaptive, conversational interface that recomposes itself per visitor in real time. A founder sees compliance content, a CISO sees security controls, all generated on the fly from your data. It's not a chatbot widget in the corner; the conversation is the page, and everything the visitor says carries through into signup and product onboarding.

3. fireworks-tech-graph: A skill that turns plain descriptions of your system into polished SVG + PNG technical diagrams. It ships with 5 visual styles, 8 diagram types, and built-in knowledge of AI/agent patterns like RAG pipelines, Mem0 memory layers, and multi-agent flows.

4. Awesome LLM Apps - 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 😉