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 😉 

Today’s top AI Highlights:

1. Make Claude Code talk less and ship more

2. Mistral Vibe just introduced Remote Agents

3. LLMs can operate your browser with just 600 LoC and a Skill

4. Multi-agent task coordinator Kanban in Hermes Agent

5. Claude Code's agent loop with DeepSeek V4, 17x cheaper

& 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

Make Claude Code talk less and ship more

Why use many token when few token do trick?

Caveman is a Claude Code skill and plugin that makes Claude talk like a caveman. It cuts roughly 75% of output tokens while keeping every bit of technical accuracy intact.

Claude’s responses and fillers like "Sure, I'd be happy to help you with that" cost tokens and add zero value. With Caveman active, Claude drops articles, kills pleasantries, and eliminates hedging, but leaves code blocks, technical terms, and error messages completely untouched. The result is faster responses, lower API costs, and honestly, funnier code reviews.

Key Highlights:

1. 75% token reduction – Strips filler words, hedging, and pleasantries from Claude's responses while preserving all technical content, code blocks, and exact error messages.

2. One-line install – Run claude install-skill JuliusBrussee/caveman And you're set.

3. Toggle on demand – Activate with /caveman or "caveman mode" plugin and switch back to normal Claude anytime with "stop caveman" or "normal mode."

Mistral Vibe just introduced Remote Agents

Mistral just shipped remote agents in Vibe - async coding sessions that run in the cloud, execute in parallel, and ping you when they're done.

Powered by Mistral Medium 3.5, a new 128B dense model built for long-horizon agentic tasks. The model merges instruction-following, reasoning, and coding into a single set of weights, scores 77.6% on SWE-Bench Verified, and is now the default across both Vibe CLI and Le Chat.

ICYMI: Vibe's CLI is an open-source terminal-native coding agent, working inside your codebase with slash-command skills, custom subagents, and MCP integrations.

Key Highlights:

1. CLI or Le Chat — Spawn remote coding agents from either surface.

2. Teleport local sessions to the cloud — Move an ongoing CLI session to a remote sandbox mid-task, with history, state, and approvals carrying across. When done, the agent opens a PR on GitHub and notifies you.

3. Mistral Medium 3.5 — Open-weights released under modified MIT, self-hostable on as few as four GPUs, with configurable reasoning effort.

4. Work mode in Le Chat — A new agentic mode that handles multi-step tasks like inbox triage, research synthesis, and cross-tool workflows, with connectors on by default and explicit approval for sensitive actions.

Try it today!

LLMs can operate your browser with just 600 LoC and a Skill

Browser Use is a tens-of-thousands-line browser framework. Now, the team turned around and shipped a 592-line alternative that lets the LLM be the framework.

Browser Harness is a new open-source project that gives an LLM a raw CDP websocket connection to Chrome, a small set of starter helpers, and a skill file - that’s it!

The agent sees exactly how its tools work at the protocol level, writes new ones when it needs them, and self-corrects when something breaks.

In one interesting example shared by the team, the agent needed to upload a file and it didn’t have the tool, so it wrote one itself and moved on.

And now, after Browser Harness blew up, the team just packaged it into Browser Use Desktop, an open-source desktop app that lets Claude Code, Codex, or any coding agent control your browser, without trying to replace your Chrome.

You can even trigger these agents by texting yourself @BU on WhatsApp.

Quick Bites

Multi-agent task coordinator Kanban in Hermes Agent
The latest version of Hermes Agent ships a Kanban multi-agent system where agents, each with their own tools, skills, and personality profiles, claim tasks off a board, fan out work through linked dependencies, and pass files via shared workspaces or git worktrees. There's a live dashboard, per-task comment threads that both humans and agents write into, heartbeat monitoring, and the whole thing is SQLite-backed so it survives crashes and reboots.

20 Claude Code tips you probably missed
This one’s a nice recap or fresher on the best hotkeys and commands to use Claude Code. It's one of those lists where you go in thinking you know most of it and come out humbled. We definitely didn’t know about 11 and 13 in the list. Worth bookmarking!

Agents can now create account, buy domain, and deploy
Cloudflare and Stripe just teamed up so coding agents can go from zero to deployed autonomously. This includes creating a Cloudflare account, buying a domain, starting a paid subscription, and shipping to production, all without any human intervention anywhere. Stripe acts as the identity provider and handles payment tokenization (with a $100/month spending cap per provider, so your agent doesn't go on a domain shopping spree), while Cloudflare auto-provisions accounts on the fly. Just install Stripe CLI + Stripe Projects plugin, and you can start! The team will also release an open protocol soon.

Tools of the Trade

1. Deepclaude - A proxy that lets you swap Claude Code's backend for DeepSeek V4 Pro, OpenRouter, or any Anthropic-compatible API. You keep the same Claude Code agent loop and UX but at roughly 17x lower cost.

2. Agent-desktop - A Rust-based CLI that gives AI agents native desktop control by reading OS accessibility trees and outputting structured JSON with stable element references. Think browser automation, but for any native app on your machine.

3. Heard - A voice companion that reads your AI coding agent's terminal replies aloud so you don't have to keep watching the screen. Wispr handles what you say to your agent; Heard handles what it says back. It monitors agent output and uses TTS to keep you in the loop while you do other things.

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 😉 

Filing an insurance claim by phone is messy: the claimant tells an emotional, unstructured story, and an agent on the other end tries to translate it into a rigid form in real time. Voice AI is built for exactly this gap.

In this tutorial, you will build a voice-first FNOL (first notice of loss) app where a claimant talks naturally and an agent assembles a structured claim packet live. The UI shows the transcript, extracted facts, missing items, routing, and an adjuster-ready handoff.

The stack is Google ADK for the workflow graph and Gemini Live for the voice.

What is Google ADK? Google's framework for building production-ready multi-agent systems. It provides model-agnostic agent orchestration, native tool integration (like Google Search), and a powerful Sequential Agent pattern that lets you chain specialized agents into sophisticated workflows.

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 voice and text FNOL intake app that:

• Lets the claimant speak or type

• Streams audio responses back in real time via Gemini Live

• Extracts structured claim facts into Pydantic schemas

• Classifies claim type and severity

• Applies deterministic rules for missing fields, required documents, fraud signals, and safety escalations

• Builds a Markdown adjuster handoff packet during the call

• Avoids promising coverage, payment, or liability

How It Works

Every time the claimant speaks or types, the app does this in the background:

1. Listen. Voice gets transcribed; text comes in directly.

2. Understand. Gemini reads the full conversation so far and pulls out structured facts like name, policy, date, location, what happened, evidence, injuries.

3. Classify. Gemini decides what kind of claim this is and how severe it looks.

4. Apply rules. Python checks: are required fields missing? What documents will the adjuster need? Are there fraud or safety red flags?

5. Decide routing. The rules pick one of four lanes: ready_for_adjuster, needs_docs, special_investigation, or emergency_escalation. A safety flag (injury, unsafe housing) always wins.

6. Build the packet. A Markdown handoff packet is assembled, plus the next thing the agent should say.

7. Update the UI. Fields, timeline, and packet refresh in the browser. The agent speaks back.

The key idea is the split of labor: Gemini handles messy human language, Python handles decisions that have to be consistent. You don't want an LLM deciding whether a claim has all its documents or whether to escalate for safety — those are exactly the decisions that need to be the same every time.

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 models

3. A code editor of your choice

4. Basic Python, FastAPI, and async familiarity

5. A browser with microphone access for voice

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 insurance_claim_live_agent_team folder:

cd awesome-llm-apps/voice_ai_agents/insurance_claim_live_agent_team

3. Install the required dependencies:

pip install -r requirements.txt

4. Grab your Gemini API key from Google AI Studio.
   

5. Copy the env file and add your key:

cp .env.example .env

6. In .env:

GOOGLE_GENAI_USE_VERTEXAI=False
GOOGLE_API_KEY=your-google-api-key

Creating the App

Project structure:

insurance_claim_live_agent_team/
├── __init__.py            # Exports root_agent for `adk web`
├── agent.py               # ADK graph + run_claim_workflow
├── schemas.py             # Pydantic data contracts
├── policies.py            # Deterministic insurance rules
├── examples.py            # Demo claimant prompts
├── requirements.txt
├── .env.example
├── live_demo/
│   ├── server.py          # FastAPI transport
│   ├── index.html         # Frontend
│   ├── styles.css         # Frontend
│   └── app.js             # Frontend
└── README.md

We skip the frontend code (index.html, styles.css, app.js). It's a static cockpit that talks to two endpoints (/api/message, /api/audio) and a WebSocket (/ws/live) — swap it for any UI you like as long as those three surfaces are honored.

schemas.py — Data Contracts

1. Pydantic models for everything passed between steps. Headline schema is ClaimNarrative - this is what the LLM extracts from a claimant's story:

class ClaimNarrative(BaseModel):
    policyholder_name: str
    policy_number: str
    contact_method: str
    date_of_loss: str
    loss_location: str
    loss_description: str
    estimated_loss_usd: Optional[float] = None
    injuries_or_safety_concerns: list[str] = Field(default_factory=list)
    evidence_available: list[str] = Field(default_factory=list)
    documents_mentioned: list[str] = Field(default_factory=list)
    # ...

One schema per pipeline step: FieldValidation, ClaimClassification, CoverageEvidenceDecision, DocumentChecklist, FraudSafetyGate, ClaimIntakePacket. Literal types lock down values like ClaimType and RoutingDecision so the rules can switch on them safely.

policies.py — Deterministic Insurance Rules

1. The boring file, by design. Five public functions, each takes structured inputs and returns structured outputs:

validate_required_claim_fields(claim)
apply_coverage_and_evidence_rules(claim, validation, classification)
generate_document_checklist(claim, classification, coverage)
fraud_signal_and_safety_gate(claim, validation, classification, coverage)
build_claim_intake_packet(...)

2. Required documents are mapped per claim type:

TYPE_REQUIRED_DOCS = {
    "home_water_damage": [
        ("Photos or video of damaged areas before cleanup", "..."),
        ("Mitigation or drying invoice", "..."),
        ("Repair estimate or contractor assessment", "..."),
    ],
    "auto_collision": [...],
    # ...
}

fraud_signal_and_safety_gate is the most consequential — if it sees injury or unsafe-living mentions, it forces routing to emergency_escalation regardless of the rest of the pipeline.

agent.py — The ADK Graph and the Workflow Bridge

Two jobs: define the SequentialAgent (root_agent), and expose run_claim_workflow for the server.

1. The graph is seven steps, alternating LLM and Python nodes:

def create_workflow() -> SequentialAgent:
    return SequentialAgent(
        name="insurance_claim_live_agent_team",
        sub_agents=[
            create_normalizer(),                            # LLM
            FunctionNode(name="ValidateRequiredClaimFields", ...),   # Python
            create_classifier(),                            # LLM
            FunctionNode(name="ApplyCoverageAndEvidenceRules", ...),
            FunctionNode(name="GenerateDocumentChecklist", ...),
            FunctionNode(name="FraudSignalAndSafetyGate", ...),
            FinalPacketNode(name="FinalClaimIntakePacket", ...),
        ],
    )

root_agent = create_workflow()

2. LLM nodes are LlmAgent with a Pydantic output_schema — that's what guarantees structured output:

def create_normalizer() -> LlmAgent:
    return LlmAgent(
        name="NormalizeClaimNarrative",
        model=MODEL,  # "gemini-3-flash-preview"
        instruction="""You are the intake specialist...
        Read the claim narrative and produce a structured ClaimNarrative.
        Do not invent policy numbers, contacts, dates, or evidence.""",
        output_schema=ClaimNarrative,
        output_key="normalized_claim",
    )

3. Python nodes wrap a handler that reads from and writes to ADK session state:

class FunctionNode(BaseAgent):
    handler: Callable[[InvocationContext], dict[str, Any]]
    output_key: str

    @override
    async def _run_async_impl(self, ctx):
        result = self.handler(ctx)
        ctx.session.state[self.output_key] = result
        yield _state_event(self.name, self.summary, {self.output_key: result})

4. Handlers delegate straight to policies.py — no logic in the graph layer:

def _validate_claim_handler(ctx):
    return validate_required_claim_fields(ctx.session.state.get("normalized_claim"))

5. The bridge that lets the live UI use this graph is run_claim_workflow:

async def run_claim_workflow(claimant_transcript, *, session_id=None, user_id="live-ui"):
    if not claimant_transcript.strip():
        return build_initial_workflow_state()

    session_service = InMemorySessionService()
    await session_service.create_session(app_name=APP_NAME, user_id=user_id, session_id=...)
    runner = Runner(app_name=APP_NAME, agent=root_agent, session_service=session_service)

    message = genai_types.Content(role="user", parts=[
        genai_types.Part(text=f"Use this claimant transcript as source of truth.\n\n{claimant_transcript}")
    ])

    async for _ in runner.run_async(user_id=user_id, session_id=..., new_message=message):
        pass

    state = (await session_service.get_session(...)).state
    # validate each output through Pydantic, return as a dict

live_demo/server.py — FastAPI Transport

1. After the refactor, server.py does no claim reasoning. It serves the frontend, manages per-claimant sessions, accepts text/audio/WebSocket, and calls run_claim_workflow:

from agent import MODEL, blank_claim, build_initial_workflow_state, run_claim_workflow

2. The bridge function is tiny:

async def _process_with_adk_graph(session, *, add_claimant_facing_reply):
    workflow = await run_claim_workflow(_claimant_text(session), session_id=session.session_id)
    if add_claimant_facing_reply:
        packet = workflow["claim_intake_packet"]
        session.transcript.append({"speaker": "Agent", "text": packet["claimant_next_message"]})
    return _state_from_workflow(session, workflow)

The agent's reply comes from the deterministic packet's claimant_next_message — no separate LLM call.

3. The three transport surfaces:

@app.post("/api/message")        # text turn
@app.post("/api/audio")          # uploaded audio (transcribed, then same path)
@app.websocket("/ws/live")       # Gemini Live bidirectional voice

For /ws/live, the graph runs as a side task (asyncio.create_task(...)), so audio keeps streaming back while the structured packet updates in the background. The user never waits on the rules.

__init__.py — Optional Surface for adk web

from .agent import root_agent
__all__ = ["root_agent"]

Two reasons it exists: it makes the folder a Python package (so the relative imports inside agent.py resolve), and it lets ADK's CLI tools — adk web, adk run, adk api_server — auto-discover root_agent.

The live demo imports run_claim_workflow from agent.py directly; adk web exercises the same root_agent through ADK's dev UI. Both hit the same graph.

examples.py — Demo Prompts

Five canned claimant narratives like basement flood, car accident with injuries, stolen laptop without a police report, travel cancellation, and a deliberately vague claim. Useful for adk web testing and rule sanity-checks.

Running the App

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

Start the backend and frontend with one command:

python -m uvicorn live_demo.server:app --reload --host 127.0.0.1 --port 4177

Open:

http://127.0.0.1:4177/index.html

Click the mic to start a live claim, or type. Watch the right panel populate fields and build the handoff packet as you talk. Try a prompt from examples.py for a quick demo.

To inspect the graph step-by-step:

adk web

Working Application Demo

Conclusion

You've built a voice-first FNOL intake app with a clean separation: schemas as contracts, policies as deterministic logic, an ADK graph as the workflow, and FastAPI as pure transport.

A few directions to play with from here:

• Support new claim types and see how far the pipeline carries you for free

• Persist conversations so claims survive a backend restart

• Expand the fraud and safety signals for richer routing

• Wire the final packet into your real claims system, CRM, or messaging tool

• Build an eval set to catch regressions when you tweak prompts or rules

The hybrid LLM-plus-rules pattern generalizes far beyond insurance!

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. Open-source replica of Claude Design

2. Cursor runtime, harness, and models now in Cursor SDK

3. Give your agent a filesystem, it gets a memory

4. Warp is now open-source

5. Convert any document into MD or JSON for agents

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

You'll also see how skills enable independent team ownership and composition at scale, doing for agents what npm did for JavaScript.

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

Open-source Replica of Claude Design

When something good ships closed-source, the clock starts on the open-source version.

Open Design is a local-first replica of Claude Design that ditches the lock-in entirely.

The trick is that it doesn't ship an agent at all. The daemon scans your machine for Claude Code, Codex, Cursor Agent, Gemini CLI, OpenCode, or whichever it finds. That same agent gets driven by a stack of 19 skills, 71 brand-grade design systems, and a sandboxed iframe preview.

Same artifact-first loop as Claude Design. None of the cloud, subscription, or model lock-in.

Key Highlights:

1. BYO agent - Whatever CLI is on your PATH becomes the design engine. No Anthropic key needed if you have Claude Code installed; no Claude Code needed if you have Codex or Gemini.

2. 19 Skills + 71 design systems - Prototypes, decks, dashboards, mobile apps, plus brand systems for Linear, Stripe, Vercel, Notion, Apple, Tesla, and 65 others.

3. Anti-slop, hard-coded - Turn 1 is always a question form. Turn 2 picks one of five locked visual directions. The agent self-critiques 1-5 before emitting.

4. Skills are just folders - Drop a SKILL.md into skills/, restart, it appears in the picker. Same convention as Claude Code.

Cursor Runtime, Harness, and Models now in Cursor SDK

The agents that power your Cursor desktop app, CLI, and web app are now just a npm install away.

Cursor has launched the Cursor SDK in public beta, giving you programmatic access to the same runtime, harness, and models that ship inside Cursor itself. Build custom coding agents in a few lines of TypeScript, run them locally or on Cursor's cloud against a dedicated VM, and pick any frontier model you want.

You get codebase indexing, semantic search, MCP server support, skills auto-loaded from .cursor/skills/, hooks for controlling the agent loop, and subagents that delegate tasks with their own prompts and models.

Cursor has also open-sourced starter projects, including a coding agent CLI, a prototyping tool, and an agent-powered kanban board.

Give Your Agent a Filesystem, It Gets a Memory

“RAG is dead” and “filesystems are all you need” are both kind of right and kind of wrong.

Agentic search on a codebase is genuinely beautiful - until you try it on folders with your notes, PDFs, transcripts, etc., and watch it fail.

SMFS is what happens when you stop picking sides. From Supermemory, it’s a mountable filesystem that turns your memory container into a real local directory. Your agent navigates it with the same ls, cat, and grep it already knows, except grep is now semantic by default.

Drop in PDFs, videos, audio, and docs - SMFS handles extraction, embeddings, and search automatically.

It’s open source, written in Rust, and plays well with Daytona, E2B, Cloudflare, and Vercel sandboxes.

Key Highlights:

1. Semantic by default - Inside a mount, plain grep hits Supermemory’s hybrid semantic index; any flag falls through to standard grep.

2. Multi-agent, shared state - Multiple agents can mount the same container - one writes, the others see it on the next pull.

3. Live profile file - A virtual profile.md at the mount root regenerates on read from every memory in the container, so the agent’s first useful action in a new directory - reading a file - just works.

4. Works where there’s no filesystem - For Cloudflare Workers, edge runtimes, and browser agents, @supermemory/bash exposes the same Unix surface as a single run_bash tool the agent calls.

Quick Bites

Warp is now open-source
Warp is now open source, dropping its client code, roadmap, and a lightweight contributor workflow on GitHub under a mix of MIT (UI crates) and AGPL v3 (everything else). OpenAI is the founding sponsor, GPT models drive the new agent management flows, and Warp still plays nicely with Claude Code, Codex, and Gemini CLI if you'd rather BYO agent. The cherry on top: build.warp.dev lets you spectate fleets of Oz agents triaging issues and shipping PRs, then jump into a live web-compiled Warp terminal to follow along.

A2A + MCP: Five Ways They Fit Together
This one is a solid playbook on how A2A and MCP fit together. Five multi-agent patterns covering everything from agent discovery to ambient event meshes that react to Pub/Sub streams in the background. The TL;DR: A2A handles agent-to-agent, MCP handles agent-to-tool, and if you're not using both you're going to be rewriting things in twelve months.

The five patterns:

1. Agent Card Discovery — every A2A agent publishes a JSON doc at a well-known URL describing its capabilities, auth, and rate limits; Agent Registry makes them findable across your org

2. Delegated Specialization — a Python coordinator hands off to a Go security agent, a Java risk agent, a TypeScript marketing agent; each team ships independently and the coordinator never knows the difference

3. Tool Bridge via MCP — one protocol for every data source and API, with 60+ ready integrations and Apigee API Hub auto-converting existing REST APIs into agent-accessible tools

4. Cross-Organization Federation — Agent Gallery's 100+ validated partner agents (Adobe, ServiceNow, Workday, Salesforce) collaborate with yours while each side enforces its own governance

5. Ambient Event Mesh — agents listen continuously on BigQuery tables and Pub/Sub streams, processing events in the background and escalating to humans via Mission Control when needed

Worth a read if you're stitching agents together right now and tired of building custom connectors for every API.

Open-source spec for Codex orchestration
OpenAI just open-sourced Symphony, a spec that turns your Linear board into a control plane for Codex agents — every open ticket gets its own agent workspace, runs continuously, and shows up as a PR for review. Internally, some teams saw landed PRs jump 500% in three weeks, though the more interesting bit is the mental shift: engineers stop babysitting sessions and start managing work. It's shipped as a Spec.md you point at your coding agent of choice, with an Elixir reference implementation — fitting, given the whole thing was built by Codex itself.

Tools of the Trade

1. Firecrawl /parse: New endpoint that converts documents like PDFs, DOCX, and XLSX into clean Markdown or JSON that AI agents can actually work with. It runs on a Rust-based engine that's up to 5x faster than before, handles files up to 50 MB, and preserves reading order and tables.

2. Gemma Chat: Vibe code without internet. This open-source Electron app runs Gemma 4 natively on Apple Silicon. You describe what you want to build, and it writes the code with a live preview that updates as the model types. No internet connection needed after the initial model download.

3. /browser-trace skill: Attaches a read-only observer to your agent's browser session, capturing network requests, DOM snapshots, screenshots, and CDP logs into a filesystem. It pairs with Stagehand, Playwright, or whatever's already driving the page so you can debug failed runs, attach mid-flight to live automations, or just keep tabs on what your agent is actually doing.

4. Helmor: A local-first macOS IDE built around orchestrating coding agents rather than writing code yourself. Built for agent orchestration, review, testing, merge, and everything around the code.

5. 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 😉 

Your agent has a 200k token context window. The instruction it actually needed was 400 tokens long. It ignored them anyway.

Those 400 tokens were buried at position 142k under six tool definitions, four reference docs, and a brand guide nobody asked it to read.

This is the most common reason agents fail in production. It's not become of the model or the framework. The prompt got too big and the right thing got buried.

Skills are the cleanest fix for this problem. Not a bigger model. Not a bigger window. Not a smarter retriever. Just a small set of design decisions about where context lives and when it loads.

Five parts make the whole thing work. Here is how each one fits.

1. A skill is a folder

A skill is not a Python class or a registered tool. It is a folder on disk with a markdown file inside it.

SKILL.md is the only required file. References hold docs the agent reads on demand. Assets hold templates and brand files. Scripts hold code the agent can execute. Everything except SKILL.md is opt-in.

Because a skill is just files, you version it in git. You diff it in pull requests. You copy it between projects. You publish it on GitHub. The format is the contract.

Same SKILL.md works across Claude Code, Codex, Gemini CLI, Cursor, Agent Development Kit, LangChain, and a growing list of agent tools and frameworks. One folder, many runtimes.

2. The first two lines are the search index

Open any SKILL.md and the first thing you see is YAML frontmatter with two fields. These two fields are not just metadata. They are the search index.

At session start, the agent loads the name and description of every installed skill. Roughly 100 tokens per skill. The body, the references, the scripts, all of it stays on disk.

When a request comes in, the model reads its own catalog and decides which skill to open. The description is what it matches against. Write a vague description and the skill never fires. Write a sharp one with concrete trigger words and the skill activates exactly when it should.

This single line is the most important piece of writing in the whole skill. People spend hours on the body and ten seconds on the description, then wonder why their skill never gets used.

Flip that ratio.

3. Progressive disclosure is the whole trick

A single skill can hold tens of thousands of tokens of instructions and reference material. An agent with twenty skills could carry hundreds of thousands of tokens. Multiple full context windows of dead weight before the user has even typed.

Progressive disclosure prevents this with three loading tiers

• L1 metadata. Name and description. Always loaded at session start. Roughly 100 tokens per skill.

• L2 instructions. The body of SKILL.md. Loaded only when the description matches a user task. Usually a few thousand tokens.

• L3 references. Files in references/, assets/, and scripts/. Loaded only when the L2 instructions explicitly point the agent there.

An agent with twenty skills installed pays the same upfront cost as an agent with one. Add a 21st skill tomorrow and yesterday's tasks cost what they cost yesterday.

The catch is that progressive disclosure only saves tokens if you actually use the tiers. Stuff every example into SKILL.md and the body balloons to 10K tokens. Now every task that triggers the skill pays that cost.

Keep SKILL.md short. Push edge cases, long examples, and reference tables into references/. The agent pulls them in only when it needs them.

4. Agent routes the query

When a request comes in, the model does what you would do looking at a toolbox. Read the labels. Pick the right one. Open it.

The user says "clean up this messy CSV and dedupe rows." The model scans the catalog of descriptions. pdf-forms, low match. brand-voice, low match. data-clean: CSV cleanup, dedup, nulls, strong match. The body of data-clean loads. Work begins.

Two details matter here.

The match is not vector retrieval. The model decides directly from descriptions inside its own context. No embedding step. No similarity score. No separate routing layer. The LLM is the router.

The match is also exclusive. Only one skill activates per task. The others stay at L1. Their bodies never enter the context window. The cost of skills you do not need is essentially zero.

This is what makes skills feel different from MCP tools or function calls. Tools are always loaded, always visible, always paid for. Skills load only when relevant.

5. Composition without context bloat

Scale this up. One agent, eight skills installed. Three different tasks come in over the course of a session.

The skills the agent did not use stay at L1. Roughly 100 tokens each, no body, no references. The body cost is paid only on the tasks that need it.

The pattern matters beyond context economics.

Teams can ship skills independently. The data team owns data-clean and sql-runner. The design team owns brand-voice and deck-build. The platform team wires up the agent. Nobody coordinates. Nobody merges prompts. Nobody rebuilds the system prompt every time a new capability lands.

Skills are doing for agents what npm did for JavaScript. Small, focused, composable units behind a clear interface.

The package manager won JavaScript. The same shape is going to win agents.

With Agent skills vs without

Put the five parts together and the gap between an agent built with skills and one built without is sharp enough to draw on a single page.

If you build agents and you have not written a skill yet, pick one workflow you do every week. Write a skill for it. One folder, one SKILL.md, version it in git. Watch the agent activate it.

The format is just files. The leverage is enormous.

Start today. One skill. One workflow. See what changes.

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. Slack for AI Employees with Karpathy’s Wiki

2. Own the full audio stack: transcript, live STT, and voice synthesis

3. Clawsweeper runs 50 Codex in parallel to scan and close PRs/issues

4. Open-source DeepSeek V4 is a bigger deal than R1

5. Turn Claude Design into a Motion Video Designer

& so much more!

Read time: 3 mins

AI Tutorial

How to Run a 24/7 AI Agent that Grows with You

I’ve been running a bunch of agents every day for months.

The problem is that I was the one constantly tweaking and learning while they just held onto context.

I tested it out by putting the same Monica agent on Hermes at the same time.

She started creating her own playbook from my edits and keeps getting better without me.

In this blog, I detailed how I did it. You’ll also understand the difference between an agent you manage and one that actually grows with you.

How to Run a 24/7 AI Agent that Grows with You

My agent started teaching itself while I slept

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

Slack for AI Employees with Karpathy’s Wiki

This is Slack reimagined, where your AI employees communicate with each other and have a shared memory.

WUPHF is an open-source working version of this with a very fun structure: a multi-agent "office" where a CEO, PM, engineers, designer, and CRO coordinate with each other and ship work.

One command (npx wuphf) opens the office in your browser, complete with a #general channel and the team already inside, claiming tasks.

Underneath it all sits the Karpathy-style wiki with a plain markdown + git for storage, BM25 + SQLite for search, and that’s it! Agents draft in private notebooks, the durable stuff gets promoted to a shared team wiki, and a "Pam the Archivist" git identity signs every wiki commit.

It's MIT, self-hosted, BYO API keys, and the whole brain lives locally.

Key Highlights:

1. One command launches a tmux/web office with a CEO, PM, engineers, designer, CMO, and CRO already inside a shared channel.

2. The shared brain is the Karpathy markdown wiki: per-agent notebooks for rough drafts, with reviewed entries promoted to the team wiki.

3. Fresh sessions per turn keep input flat at ~87k tokens with a 97% cache hit rate. Accumulated-session orchestrators climb to ~484k over the same window.

4. Mix runtimes freely - Claude Code, Codex, and OpenClaw agents can share the same office and the same wiki.

Own the full audio stack: transcription, live STT, and voice synthesis

Mistral Speech gives you three open-weights models in one coherent stack: batch transcription, live STT, and natural voice synthesis. Build and deploy a full audio pipeline via API, or self-host on-prem and at the edge.

Key Highlights:

1. Voxtral Mini Transcribe 2 - ~4% word error rate on FLEURS at $0.003/min. Speaker diarization, context biasing for up to 100 terms, and recordings up to 3 hours in a single request.

2. Voxtral Realtime - Live transcription with latency configurable down to sub-200ms. At 480ms, within 1-2% WER: the voice agent sweet spot. Runs on phones, laptops, and smartwatches.

3. Voxtral TTS - 70ms model latency, ~9.7x real-time factor, voice cloning from 3 seconds of audio across 9 languages. Emotion-steering built in.

4. Deployable anywhere - On-prem, private cloud, serverless, or Mistral Compute. GDPR and HIPAA-compliant.

Try it now!

Clawsweeper Runs 50 Codex in Parallel to Scan and Close PRs/Issues

4,000 GitHub issues closed in a single day, by a bot, not a burnout.

The creator of OpenClaw just shipped ClawSweeper, an automated maintenance bot that runs 50 Codex instances in parallel to scan, triage, and close stale or already-resolved issues and PRs across the OpenClaw repo.

Here's the context: OpenClaw's explosive growth left the repo sitting on 13,500+ open items. That’s an impossible backlog for any human team. ClawSweeper tackles this by running parallel review shards powered by GPT-5.4, each checking out the repo at main and deeply analyzing whether an issue has already been fixed, can't be reproduced, or is just too incoherent to act on. It only closes when the evidence is strong, and maintainer-authored items are never touched.

Key Highlights:

1. ClawSweeper only closes for five specific reasons: already implemented, unreproducible, belongs as a skill/plugin, incoherent, or stale past 60 days. Everything else stays open, untouched.

2. Codex runs without GitHub write tokens and against a read-only checkout. If it leaves even a single untracked file behind, the review fails.

3. Every proposed close includes a hash of the issue's state at review time. If anything changes between proposal and apply, the closure is automatically skipped.

4. A planner scans all open items and prioritizes by activity: active issues first, then PRs, then recent issues, then older weekly reviews. The most relevant work gets handled first.

Quick Bites

Building agents that reach production systems with MCP
Anthropic just dropped a guide on wiring up agents to production systems via MCP. It leans into hard-won patterns from running 200+ MCP servers at scale. If you're building agents that need to talk to real infrastructure behind auth, this is the playbook. Some of our takeaways:

• Don't mirror your API 1:1 into MCP tools. Group tools around what the agent is actually trying to do. One create_issue_from_thread beats four chained primitives every time.

• If your service has hundreds of operations (think AWS, K8s), skip the mega-toolset. Expose a thin tool surface that accepts code: the agent writes a short script, your server runs it in a sandbox against your API, and only the result returns. Cloudflare’s MCP inspired by Code Mode is a great example.

• Instead of stuffing all tool definitions into context upfront, lazy-load them at runtime. Pair that with programmatic tool calling for another ~37% token reduction.

• MCP gives agents access to tools; skills teach them how to use those tools well. Bundling both as plugins gives the best of both.

Open-source DeepSeek V4 is a bigger deal than R1
DeepSeek V4 is a 1.6T-param MoE model with 1M native context, MIT-licensed, scoring within a hair of Opus 4.6 on SWE-bench (80.6% vs 80.8%), and it costs $3.48 per million output tokens. For reference, GPT-5.4 charges $30. That's a different economic model entirely, and it's open-weight so you can self-host it. Add in that it was trained on Huawei Ascend 950 chips (not Nvidia). This a serious inflection point: the best open-source model in the world now sits at ~95% of frontier performance for ~12% of the price.

OpenAI open-sources a local-first PII redaction model
OpenAI dropped Privacy Filter, an open-weight 1.5B-parameter model (only ~50M active) that detects and redacts PII across eight categories like names, addresses, API keys, and the works in a single pass with a 128k context window. It runs locally on a laptop or even in a browser, so your sensitive text never has to leave your machine, and it ships under Apache 2.0, so you can fine-tune and commercialize freely.

Tools of the Trade

1. HyperFrames: Open-source framework by HeyGen that turns HTML into rendered video. It ships as a Skill you can add to Claude (Code or Design) that teaches it how to write video compositions in HTML. Just prompt what you want, Claude authors the scenes with proper timelines and animations, and you render to MP4 locally.

2. Hermes Labyrinth: An observability plugin for Hermes Agent. It turns agent activity into a map of crossings: prompts, tool calls, tool results, failures, model switches, subagents, approvals, memory hits, redactions, context compression, cron runs, and reportable evidence.

3. Claude Code Hook - Context Timeline: A monitoring hook that visualizes your main agent's context window and all spawned subagents as a live timeline from session start. It makes it way easier to track what's happening across parallel contexts than squinting at console output.

4. Clicky: A free Mac menu bar app by Farza that lets you talk to AI and spin up agents that can build apps, do research, and interact with native Apple apps like Notes, Calendar, and Reminders. It's designed for consumers with zero setup. Just install and start talking.

5. 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 😉 

Today’s top AI Highlights:

1. Cloudflare's persistent managed memory for AI agents

2. Talk to your coding agent, have it talk back

3. New Kimi model for your Hermes and OpenClaw

4. OpenAI drops its new frontier model GPT 5.5

5. Google Agent CLI to build and deploy ADK agents from terminal

& so much more!

Read time: 3 mins

AI Tutorial

How to Run a 24/7 AI Agent that Grows with You

I’ve been running a bunch of agents every day for months.

The problem is that I was the one constantly tweaking and learning while they just held onto context.

I tested it out by putting the same Monica agent on Hermes at the same time.

She started creating her own playbook from my edits and keeps getting better without me.

In this blog, I detailed how I did it. You’ll also understand the difference between an agent you manage and one that actually grows with you.

How to Run a 24/7 AI Agent that Grows with You

My agent started teaching itself while I slept

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

Cloudflare's Managed Persistent Memory for AI Agents

There's a weird tension at the heart of every long-running agent: keep everything in context and watch quality rot, or prune and lose important things.

Cloudflare's new Agent Memory, out in private beta, picks a third option - extract the important stuff from conversations at compaction time and make it retrievable on demand. The API is deliberately small: ingest a conversation, remember something specific, recall what you need, list, or forget.

Unlike local-first setups like OpenClaw where memory is md files the model writes itself, this is a managed architecture built for memory at scale, where ingestion quality and retrieval sophistication actually matter. You can call it from a Worker via binding or hit the REST API from anywhere, and it plugs directly into the Cloudflare Agents SDK.

Key Highlights:

1. What sticks, what fades - Memories get sorted into facts, events, instructions, and tasks. Facts update in place instead of piling up, and tasks are ephemeral by design.

2. Retrieval that actually holds up - Five search channels run in parallel and get fused together, so queries work whether you phrase them as keywords or questions.

3. Smaller models often win - Llama 4 Scout handles the structured work, Nemotron 3 does synthesis. Bigger wasn't better for most stages.

4. Already running inside Cloudflare - It’s already powering as an OpenCode plugin with shared team memory, an agentic code reviewer, and an internal chatbot. Early access is open via waitlist if you're building agents on Cloudflare.

Talk to Your Coding Agent, Have it Talk Back

Mistral Vibe is a terminal-native coding agent powered by Mistral's models that lets you explore, modify, and interact with your codebase through natural language. The latest update adds voice mode: toggle it on to give instructions by voice instead of typing, and enable text-to-speech to have Vibe read its output back to you.

Key highlights:

1. Voice input - Toggle voice mode on with /voice to talk to Vibe instead of typing.

2. Text-to-speech readouts - Vibe can read its output back to you, keeping you in flow without having to read through long responses.

3. Chat rewind - /rewind lets you navigate back through your conversation and fork from any point. Useful for exploring a different approach without starting a new session.

4. Parallel tool execution - Vibe now reads multiple files, runs searches, and calls several sub-agents simultaneously to speed up sessions.

5. Session resume - Pick up any previous session with /resume and full context intact. Or launch with vibe --continue to jump straight back into your last session.

Get started now!

New Kimi Model for Your Hermes and OpenClaw 🦞

This open-source model ran autonomously for 5 days straight, managing incidents, running code, handling system ops with zero human babysitting.

In another run, it spent 13 hours rewriting an 8-year-old financial matching engine, made 1,000+ tool calls, and more than doubled throughput.

That’s Kimi K2.6 by you for by Moonshot AI, a 1T MoE model (32B active) built for long-horizon coding, proactive 24/7 agents, and multi-agent orchestration.

The benchmarks hold up: 58.6 on SWE-Bench Pro, 80.2 on SWE-Bench Verified, 66.7 on Terminal-Bench 2.0, and 54.0 on HLE with tools, sitting alongside Claude Opus 4.6 and GPT-5.4 while being fully open-weight.

Beyond text and code, Moonshot has clearly leaned hard into design this time — K2.6 turns a single prompt into Awwwards-level frontends with hero sections, scroll animations, and even generated image/video assets.

Key Highlights:

1. Agent Swarm baked into the model - K2.6 can decompose one prompt into up to 300 specialist sub-agents running 1000s of coordinated steps in parallel, with the model itself acting as orchestrator.

2. Use with OpenClaw and Hermes - K2.6 is explicitly tuned to power proactive always-on agent frameworks like OpenClaw and Hermes. Definitely worth trying if you’re still struggling with the models.

3. Claw Groups for team-style multi-agent work - A research preview where you and your teammates can bring your own agents, running on different devices, using different models, with their own tools and memory, into one shared workspace. K2.6 sits at the center as coordinator, assigning work to whichever agent is best suited and reassigning tasks if one fails.

The model is OpenAI/Anthropic-API compatible and available now via kimi.com, the Moonshot API, Kimi Code CLI, and Hugging Face.

Quick Bites

Codex goes from coding agent to desktop Copilot
The new Codex takes its "(almost) everything" tagline pretty seriously: background computer use lets multiple agents click around your Mac without stepping on your own work, a native browser turns frontend iteration into a point-and-annotate loop instead of a prompt-and-hope one. Add image generation inside the agent loop, a memory preview, and cross-session automations that resume tasks across days, and OpenAI is quietly reshaping Codex into a desktop control surface rather than a coding sidekick. Rolling out now to Codex desktop app users.

Email inbox for your AI agents
Every agent can now have their own inbox with Cloudflare's Email Service in public beta. Besides just inbox, it enables a bunch of features like asynchronous work, persistent state across replies, and a channel users already know how to use. It's a neat counterpoint to the default assumption that agents need bespoke chat interfaces. Also shipping: an Email MCP server, CLI tooling, and an open-source Agentic Inbox you can deploy in one click.

OpenAI drops its new frontier model GPT 5.5
OpenAI shipped GPT-5.5 today (codename "Spud"), six weeks after 5.4 and one week after Opus 4.7. Interesting to see the release cadence now measured in "days since last frontier model." 😅 It takes the top spot on Terminal-Bench 2.0 (82.7%), FrontierMath Tier 4 (35.4%), and long-context retrieval at 1M tokens, while Opus 4.7 hangs onto SWE-Bench Pro and MCP Atlas. API access is "coming very soon" at $5/$30 per million tokens, with the Pro variant at a spicy $30/$180.

OpenAI and Google shipped their enterprise agent platforms on the same day
Google's Gemini Enterprise Agent Platform absorbs Vertex AI. All future roadmap ships through Agent Platform, which bundles Agent Studio (low-code), an upgraded ADK, and a proper governance stack: Agent Identity, Registry, Gateway, plus runtime that supports multi-day workflows with persistent Memory Bank. It gives a single platform to build agents, scale to production, establish centralized control, and optimize with full traces.

A few hours later, OpenAI released Workspace Agents in ChatGPT. These are Codex-powered team agents that keep running while you're offline, plug into Slack, Drive, Salesforce, and Notion, and can be scheduled or triggered by events. Build one in the sidebar by describing a workflow in plain English, then let it handle month-end close or inbound lead routing while your team does literally anything else. Free until May 6, after which credit-based pricing kicks in.

Tools of the Trade

1. Agents CLI in Agent Platform: Google released an open-source CLI that gives AI agents like Claude Code, Cursor, and Gemini CLI a machine-readable path into Google Cloud's agent stack. Describe the agent in a simple prompt, and they use CLI + the bundled skills to scaffold an ADK project, run evals, and deploy to Agent Runtime, Cloud Run, or GKE.

2. Mercury: Open-source CLI and Telegram AI agent that asks before it acts, like shell blocklists, folder-scoped file access, and explicit approval for sensitive commands. Personality lives in soul.md and persona.md, and daily token budgets keep it from burning through your API credits.

3. Kimi Vendor Verifier: Moonshot’s open-source toolkit that checks whether third-party inference providers are actually running Kimi K2 correctly. It runs six benchmarks to separate real model issues from sloppy engineering at the vendor layer.

4. Cua Driver: An open-source macOS driver that lets any agent like Claude Code, Codex, or your own click and type inside real Mac apps in the background, without stealing your cursor or pulling focus across Spaces. It works by tapping into a few of Apple's private, undocumented system APIs to deliver input directly to a target app, so the app responds while your foreground window keeps everything it had.

5. 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 😉 

Today’s top AI Highlights:

1. One npm to give your AI Agents the entire live web

2. AI coding agent that adapts to your workflow

3. Build your own agents that run infinitely in the cloud

4. Run your Claude Code Routines on autopilot

5. Self-improving agent skills with built-in eval loop

& so much more!

Read time: 3 mins

AI Tutorial

How to Run a 24/7 AI Agent that Grows with You

I’ve been running a bunch of agents every day for months.

The problem is that I was the one constantly tweaking and learning while they just held onto context.

I tested it out by putting the same Monica agent on Hermes at the same time.

She started creating her own playbook from my edits and keeps getting better without me.

In this blog, I detailed how I did it. You’ll also understand the difference between an agent you manage and one that actually grows with you.

How to Run a 24/7 AI Agent that Grows with You

My agent started teaching itself while I slept

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

One npm to Give Your AI Agents the Entire Live Web

One npm install and a Skill markdown file - that's all it takes to give your coding agent full access to the live web.

TinyFish just released their CLI + Agent Skill that lets Claude Code, Codex, Cursor, OpenClaw, and other agents autonomously call four web primitives directly from the terminal: Search, Fetch, Browser, and Agent.

Everything runs on their infrastructure, so you can automate workflows at scale.

You install the skill file once, and your agent figures out the rest: which endpoint to hit, how to structure the call, where to write the output. No integration code needed.

All four primitives are built in-house on TinyFish's custom Chromium engine with 28 anti-bot mechanisms at the C++ level. The platform already ranks #1 on Mind2Web (89.9% accuracy) with 40M+ operations running for clients like Google, DoorDash, and Volkswagen.

Key Highlights:

1. Skills over MCP for execution: The skill approach uses 87% fewer tokens per operation, writes output to the filesystem instead of the context window, and delivers 2x higher task completion on complex tasks.

2. End-to-end signal loop: Because TinyFish owns search, fetch, browser, and agent, every run teaches the entire stack to improve - something you can't build by assembling third-party APIs.

3. One platform, one session: Same IP, same fingerprint, same cookies across your whole workflow. Sites see one client, not five disconnected tools making separate requests.

4. Free tier available: 500 steps, no credit card required, with an open-source cookbook and skills on GitHub.

Mistral Vibe: An AI Coding Agent That Adapts to Your Workflow

Mistral Vibe gives you a configurable agent runtime: composable skills, custom subagents, unified modes, MCP integrations, and fine-grained control over what the agent is allowed to do.

For developers who want their tools to work the way they work, this is worth a close look.

Key highlights:

1. Unified agent modes: Configure custom modes that combine tools, permissions, and behaviors. Switch contexts without switching tools - from a read-only exploration mode to a fully autonomous execution mode, all managed through a single config.

2. Custom subagents on demand: Define specialized agents for recurring tasks: deploy scripts, PR reviews, test generation. Invoke them when needed; they run independently and return results asynchronously.

3. Skills with .agents/skills/ standard support: Skills extend agents with new tools, slash commands, and specialized behaviors. Vibe now supports the .agents/skills/ standard, improving interoperability across agent tooling. 

4. Web search, notifications, and session resume: The latest updates add web search mid-session, ping notifications when the agent needs attention, and /resume to continue any previous session with full context.

5. MCP in two steps: Add your preferred tool to config.toml and it's connected. No wrappers, no boilerplate beyond the config tweak and an AGENTS.md file in the workspace.

Try it today!

Build Your Own Agents that Run Infinitely in the Cloud

Vercel looked at how Stripe, Spotify, and Block build internal coding agents, and decided to open source the entire playbook.

Open Agents is a ready-to-fork platform for spinning up cloud coding agents that go from a chat prompt to committed code changes, no laptop required.

The platform separates the agent brain from its execution sandbox, which turns out to be the key architectural decision. It means your model choices, sandbox lifecycle, and agent logic can all move independently. It ships with a chat UI, durable workflow runtime, isolated VMs with git baked in, and multi-model support through AI Gateway.

Everything deploys on Vercel infrastructure and the repo is explicitly built to be customized, not consumed.

Key Highlights:

1. Three-Layer Design: Web app handles auth and UI, the agent runs as a durable workflow outside the sandbox, and the VM provides filesystem, shell, and git access. Clean separation means each layer scales on its own.

2. Workflows That Don't Die: Agent runs survive restarts, retry failures, and auto-checkpoint. You can disconnect and reconnect to a running session from anywhere.

3. Sandbox-Per-Session: Every coding session gets an isolated environment with repo cloning, branch management, auto-commit, and optional PR creation. Sandboxes hibernate on inactivity and resume from snapshots.

4. Built to Fork: Not a SaaS product, it's a template. Deploy your own instance, wire up your GitHub App, swap in your preferred models, and build your team's custom coding agent platform.

Quick Bites

Run your Claude Code Routines on autopilot
Anthropic just shipped "Routines" for Claude Code. Configure a prompt, point it at a repo and your connectors, then let it run on a schedule, via API webhook, or in response to GitHub events, all on Anthropic's cloud so your laptop can stay shut. Think nightly issue triage, auto-porting PRs across SDKs, or Datadog alerts that arrive pre-triaged with a draft fix. Available today across all paid plans, ​​with Claude Code on the web enabled.

What really is an Agent Harness?
Theo's latest video is the most fun explanation of AI coding harnesses you'll find — he builds one in ~60 lines of Python, then proceeds to lie to the model about what its tools do (it just believes you), swap the entire toolset for a single bash command (the model figures out file I/O on its own), and show why the same Opus model jumps from 77% to 93% just by moving it into Cursor. His core argument: the harness is the product, and whoever obsessively tweaks their system prompts and tool descriptions per model wins. Do watch this.

Turn your AI prompts in Chrome into reusable Skills
Chrome now lets you turn your best Gemini prompts into saved Skills - reusable, one-click AI workflows you can fire on any page or across multiple tabs. Great abstraction: instead of re-typing the same prompt every time you hit a recipe or a product page, you save it once, customize it, and trigger it with / going forward. Google's also shipping a curated Skills library with ready-made options, and your saved Skills sync across all signed-in Chrome desktops.

Claude Code's new desktop app is built for parallel agents
Anthropic just dropped a major redesign of the Claude Code desktop app, and it's clearly built for the multi-agent workflow most of us have been using - spinning up parallel sessions across repos, each doing its own thing while you play air traffic controller. The new sidebar tracks all active sessions, there's a drag-and-drop layout with an integrated terminal and file editor, and side chats let you branch off quick questions without polluting the main task context. Available now on Pro, Max, Team, and Enterprise.

Tools of the Trade

1. Self-Improving Agent Skills: Automatically optimize your agent skills using a multi-agent system built with Google ADK (Agent Development Kit) and Gemini. Upload a skill, let the agents generate test scenarios and evaluation criteria, then watch as three specialized ADK agents collaborate to improve your skill through iterative optimization.

2. Kontext CLI: Open-source tool that wraps AI coding agents with enterprise-grade identity, credential management, and governance. Instead of copy-pasting long-lived API keys, you declare dependencies, and the CLI handles OIDC auth, short-lived token exchange, and automatic expiry.

3. Claude Reflect: A Claude Code plugin that builds persistent memory by automatically capturing your corrections and preferences during coding sessions, then syncing them to CLAUDE.md so Claude doesn't repeat the same mistakes. It also analyzes your session history to spot repeating workflows and generates reusable slash commands from them.

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)

Hot Takes

1. Markdown is the new Python

   ~ Theo - t3.gg
   

2. the ai labs, in competing with each other, are burning huge amounts of the commons on public trust in ai to win minor points against the others. their lobbyists, pr machines, lawsuits. it’s the very opposite of what marxist class struggle analysis would tell you
   ~ roon

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 running six agents on OpenClaw for months. They work. But the longer I ran them, the more I noticed a tax: I was maintaining the system more than the system was improving itself.

I kept updating SOUL.md files, pruning stale memory, and repeating the same corrections across agents. The agents were not getting better on their own. I was getting better at managing them.

Most agents can store context. Far fewer can turn completed work into reusable method. That is the difference I wanted to test.

If you haven't read my previous article about OpenClaw, read that here:

How I Built an Autonomous AI Agent Team That Runs 24/7

Full step-by-step tutorial to make your own Agent Team with OpenClaw

The correction loop

I started calling my approach corrective prompt-engineering.

You watch the agent, notice a failure, explain the fix, update memory or instructions, and wait for the behavior to stick. Kelly's early drafts were full of emojis. I told her: no emojis, no hashtags, short punchy sentences. After a week, she got it. Dwight captured too much noise. I told him to focus on signal. He adjusted.

That loop works. But it has a hidden assumption: you are the learning system.

Every improvement depends on you noticing the problem, diagnosing it, and writing down the correction. The agents do not get better while you sleep. They get better when you pay attention.

The experiment

I kept the OpenClaw squad running, but set up a second Monica on Hermes Agent. Same job. Same Mac Mini. Same access to Dwight's intel files. Not a replacement. Just a parallel test.

Hermes Agent is open-source from Nous Research. I was skeptical. Every agent tool claims some version of "memory" and "learning." Most of them mean "we store your chat history." That is not learning. That is hoarding.

Setup was simple. One command:

curl -fsSL https://raw.githubusercontent.com/NousResearch/hermes-agent/main/scripts/install.sh | bash

Then 'hermes setup'. It detected OpenClaw on the Mac Mini and offered to import settings, memories, and API keys. For Telegram, it walked me through BotFather setup. I sent the token and it connected. One tip: use a frontier model. The learning loop needs strong reasoning to work well.

The first thing that felt different

The first time I checked '~/.hermes/skills/' and found files I did not create, something clicked.

The one that stood out was 'local-writing-canon-analysis/SKILL.md'. Monica had written a procedure for reading my published articles before drafting in my voice. Not "I know your style" in the abstract. More like: read the shipped work, then infer the voice from what actually survived editing.

The file captured concrete editorial rules: keep the compounding thesis, avoid framing new topics as product comparisons, center the piece on outcomes like memory and reuse rather than features.

I did not write it. She did. She watched what I kept, what I cut, and wrote down the pattern. Other skills showed up too: operational playbook, workflow procedures, reusable task patterns. Some were useful. Some were generic. But the default behavior, turning completed work into reusable procedure, was new.

The other thing that stood out was recall. When I searched for telegram OR gateway OR restart OR stuck, Hermes agent surfaced the exact troubleshooting arc from a previous session: the polling conflict, the lesson that gateway status alone is not proof of health, and the practical fix path. All from a conversation weeks earlier that nobody had manually promoted into memory.

The work leaves residue. Not just a memory of what happened, but a method for next time.

Who owns the correction loop

OpenClaw Monica improves when I notice a problem and teach the fix. I notice a problem, give feedback, and she stores the correction for next time. The improvement depends on both of us.

Hermes Monica closes more of that loop herself. After a complex task, she evaluates what happened, decides what is worth keeping, and writes it into a skill file. I can inspect it, edit it, or delete it. But I did not have to initiate it.

That is the shift that matters. OpenClaw mostly stores what I explicitly teach. Hermes tries to turn finished work into future procedure.

The difference I cared about was not recall architecture. It was who owned the improvement loop.

What still breaks

Agents still hallucinate confidence. Self-improvement is not self-verification.

During a migration session, Monica treated the Hermes migration archive as if it contained everything from OpenClaw. It did not. The actual source of truth was the live '~/.openclaw/' workspace. She inferred completeness from partial data and moved forward with confidence she had not earned.

The Telegram gateway was the other one. After a restart, the gateway reported as loaded, but the bot was not responding. launchd said the service was running. The live responder was dead. Status screens flatter you. Logs tell the truth.

Monica turned that failure into a recovery skill on her own. The file sits at ~/.hermes/skills/autonomous-ai-agents/hermes-telegram-gateway-recovery/SKILL.md. It includes a diagnostic sequence: check gateway status, inspect logs, run the safe restart script, verify a real process plus Telegram reconnect before declaring success.

That skill was not prompted. She hit the problem, solved it, and wrote the playbook (aka skill)

Mistake goes in. Procedure comes out.

This is not automatic perfection. Some generated skills were too generic. Some captured the wrong level of abstraction. I still had to inspect, prune, and occasionally delete them. The difference was not that supervision disappeared. The difference was that useful procedure started showing up without me authoring every improvement by hand.

Running both

The OpenClaw squad handles research, content drafting, code review, and the newsletter on cron schedules. Hermes Monica runs as the chief of staff experiment on the same Mac Mini. She reads the same intel files Dwight produces on OpenClaw. Dwight writes DAILY-INTEL.md. Monica reads it. The handoff is a markdown file on disk.

OpenClaw gives me manual control and predictability. Hermes gives Monica a more self-maintaining improvement loop.

Both support the agentskills.io standard, so skills are portable across OpenClaw, Hermes, Claude Code, and Cursor. Nothing is locked to one platform.

I did not plan to run both long-term. But they complement each other. The agents I want full control over stay on OpenClaw. The agent I want to watch improve more autonomously runs on Hermes.

How to test this yourself

Start the boring way: one agent, one job, one recurring workflow. Install Hermes with one command. Run 'hermes setup'. Pick a frontier model. Connect Telegram.

The question is not whether day one looks good. The question is whether day fourteen is better without you hand-tuning every session.

If you are already running OpenClaw, run Hermes alongside it. During setup, Hermes detects OpenClaw and offers to import your settings. Pick one agent. See what happens.

Day 30 versus day 1

The system that maintains itself compounds faster than the one that depends on you.

OpenClaw is an agent you actively shape. Hermes is an agent that turns more of its own work into future procedure and improve itself. Not universally better. A different learning loop.

The best 24/7 agent is not the one that gives the best first answer. It is the one that gives a better answer on day 30 than day 1. Without you having to teach it every lesson by hand.

Start with one agent. One job. Let it run. Then check whether day 30 is better than day 1.

That is the test.

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. Ship production-ready voice agents with open-weight TTS

2. Google's best engineering practices in 20 Agent Skills

3. Karpathy-inspired CLAUDE.md file to improve Claude Code behavior

4. Get 100x from your AI Agents with Thin Harness and Fat Skills

5. Own your memory for your agent harness

& so much more!

Read time: 3 mins

AI Tutorial

How I Built an Autonomous AI Agent Team That Runs 24/7

Six AI agents run my entire life while I sleep.

Not a demo. Not a weekend project.

A real team that works 24/7, making sure I'm never behind. Research done. Content drafted. Code reviewed. Newsletter ready. By the time I open Telegram in the morning, they've already put in a full shift.

By the end of this, you will understand exactly how to build an autonomous AI agent team that runs while you sleep.

How I Built an Autonomous AI Agent Team That Runs 24/7

Full step-by-step tutorial to make your own Agent Team with OpenClaw

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

Ship Production-Ready Voice Agents with Open-weights TTS

Voxtral TTS is a lightweight 4B parameter text-to-speech model with state-of-the-art performance in multilingual voice generation. It goes beyond reading text aloud, capturing a speaker's personality: natural pauses, rhythm, intonation, and emotional dexterity. Available now via API, Mistral Studio, and open weights on Hugging Face.

Key highlights:

1. Emotion-aware speech generation - Contextual understanding (neutral, happy, sarcastic, and more) determines whether output sounds natural or robotic. Voxtral TTS models both meaning and personality, not just pronunciation.

2. Zero-shot custom voice context in 9 languages - Provide a 5-25 second voice prompt and the model adapts to accent, inflection, rhythm, and even disfluencies. Supports English, French, German, Spanish, Dutch, Portuguese, Italian, Hindi, and Arabic.

3. Cross-lingual voice adaptation - Generate speech in one language using a voice prompt in another. A French voice prompt with English text produces natural French-accented English, useful for cascaded speech-to-speech translation.

4. 70ms model latency, ~9.7x real-time factor - Built for voice agent applications. Streams natively and integrates into any existing STT and LLM stack.

5. Beats ElevenLabs Flash v2.5 on naturalness - Human evaluations show Voxtral TTS wins on flagship voices (58.3% vs 41.7%) and voice customization (68.4% vs 31.6%).

Try it now!

Google's Best Engineering Practices in 20 Agent Skills

Google's Addy Osmani just packaged 14+ years of senior engineering judgment into Markdown files, and now your AI coding agent can follow them.

He open-sourced Agent Skills, a collection of 20 structured engineering workflows as Skills and 7 slash commands that cover the full software development lifecycle, from writing specs to shipping code. Each skill is a step-by-step process with verification gates, defined inputs/outputs, and anti-rationalization tables that prevent your agent from taking shortcuts like skipping tests or jumping straight to code.

The skills map to six development phases (Define → Plan → Build → Verify → Review → Ship), and they bake in real engineering principles like Hyrum's Law, Chesterton's Fence, and trunk-based development.

The repo has already crossed 14K stars already in just a couple of days already!

Key Highlights:

1. Workflows, Not Prompts - Each of the 20 skills has defined inputs, outputs, and verification gates. The agent can't skip to the next step without completing the current one.

2. 7 Slash Commands - /spec, /plan, /build, /test, /review, /code-simplify, and /ship map to the full development lifecycle, making it easy to invoke the right process at the right time.

3. Three Specialist Personas - Ships with code-reviewer, test-engineer, and security-auditor agent personas you can load for targeted review workflows.

You need to check it out now!

Karpathy-inspired CLAUDE.md File to Improve Claude Code Behavior

Andrej Karpathy diagnosed exactly how LLMs fail at coding. And now there's a one-file fix you can install in 10 seconds.

andrej-karpathy-skills is an open-source CLAUDE.md file by developer Forrest Chang that encodes four behavioral principles directly into Claude Code, all derived from Karpathy's observations with building using AI coding agents.

Back in January, Karpathy documented how he shifted from mostly manual coding to 80% agent coding in a matter of weeks. But he was equally blunt about the failure modes: agents making wrong assumptions without checking, over-complicating everything, and quietly messing with unrelated code as side effects.

This project turns those observations into guardrails. Drop the file in your project root, and Claude Code automatically picks up the constraints for cleaner diffs, fewer rewrites, and agents that pause to ask before assuming.

Key Highlights:

1. Assumptions get surfaced, not buried - The file forces the agent to explicitly state what it's assuming and ask for clarification when multiple interpretations exist, instead of silently picking one.

2. Simplicity is enforced, not suggested - If 200 lines could be 50, rewrite. No speculative flexibility, no abstractions for single-use code, no features nobody asked for.

3. Surgical precision on edits - The agent only modifies what's directly relevant to the task — no touching adjacent comments, no reformatting, no surprise refactors.

4. Success criteria over step-by-step hand-holding - Inspired by Karpathy's observation that LLMs are best when looping toward verifiable goals: write the test first, then make it pass.

Quick Bites

OpenClaw’s latest update might make your Claws better with GPT-5.4
A huge release dropped by the OpenClaw team today with a formal GPT-5.4 vs Opus 4.6 agentic parity gate baked into the release pipeline. It’s a clear signal that the project is treating GPT-5.4 as a first-class citizen post-Anthropic lockout. The update also ships ChatGPT memory import ingestion, richer video generation modes, and a pile of fixes for the OAuth/transport bugs that plagued early 5.4 adopters. If you rage-quit Claude after the April 4 subscription crackdown and found GPT-5.4 underwhelming, this is the release worth retesting with retuned bootstrap files.

Get 100x from your AI Agents with Thin Harness and Fat Skills
If you've been thinking about how to structure AI agents, Garry Tan's "thin harness, fat skills" essay is a really satisfying read. The gist: stop cramming logic into bloated orchestration layers with 40 MCP tools. Instead, put judgment into rich markdown skill files and push execution into fast, deterministic tooling underneath. He walks through a real system at YC where matching skills self-improve by analyzing mediocre event feedback, which is exactly the kind of compounding loop that makes you go "oh, right, that's how this should work." Do give it a read.

Own your memory for your agent harness
The thing that makes your AI agent actually good over time isn't the model, it's all the context it's built up about you, your work, and your preferences. Harrison Chase connects this nicely to why owning your agent harness matters: when you use a closed agent harness, you're giving away your agent's memory. And memory is really just context! Model providers know this, which is why they're quietly pulling more state behind their APIs. His story about accidentally losing his email agent's memory and having to reteach it everything from scratch is a perfect example of why this matters. Another interesting read coming on X!

Leaked screenshots from Anthropic show Full-Stack App Builder
Another (rumoured) leak from Anthropic showing a Lovable-like interface where you can describe apps in natural language, pick templates for chatbots, games, or photo albums, and it spins up full-stack apps. Powered by Claude Opus 4.6, it offers live previews, one-click publishing, and more. Not sure how true this is, but we won’t be surprised!

Tools of the Trade

1. Multica: Turns coding agents into real teammates. Assign issues to an agent like you'd assign to a colleague, and they'll pick up the work, write code, report blockers, and update statuses autonomously. Your agents show up on the board, participate in conversations, and compound reusable skills over time. Works with Claude Code, Codex, OpenClaw, and OpenCode.

2. RCLI: A fully on-device voice AI for macOS that runs a complete STT → LLM → TTS pipeline natively on Apple Silicon, no API keys needed. It can control 38 macOS actions by voice (Spotify, volume, screenshots, etc.), do local RAG over your documents with ~4ms retrieval, and claims up to 550 tok/s on M3+.

3. just-bash: A sandboxed bash implementation in TypeScript from Vercel, designed to be the execution environment AI agents use when they need to run shell commands. It provides an in-memory filesystem, broad Unix command coverage, and configurable execution limits to prevent runaway scripts.

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)

Hot Takes

1. vibecoding is fentanyl for people with an iq over 120

   ~ Blair Dulder CPA™
   
   

2. OpenAI is starting to look like Google in 2002 & Anthropic is starting to look like Yahoo in 2002.

   ~ kache

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 😉