unwind ai

/goal in Claude Code, Codex, and Hermes Agent

Shubham Saboo — Tue, 12 May 2026 12:30:00 +0000

Today’s top AI Highlights:

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

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.
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.
Multi-screen and multi-Space aware: First-class support for moving windows between Spaces, switching desktops, and targeting elements on specific displays.
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:

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.
Emotion-aware output: Contextual understanding (neutral, happy, sarcastic, and more) determines whether output sounds considered or robotic.
70ms model latency, ~9.7x real-time factor: Streams natively and integrates into any existing STT and LLM stack.
Voice cloning from 3 seconds of audio: Adapts to tone, personality, rhythm, and intonation. Zero-shot, no fine-tuning required.
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:

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

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

Subscribe now for FREE!

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

Shubham Saboo — Sat, 09 May 2026 23:07:20 +0000

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.

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!

Subscribe now for FREE - Get instant access to more LLM, RAG & AI Agent tutorials

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:

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

Python installed on your machine (version 3.12 is recommended)
Your Gemini API key for using Gemini Embedding 2
A code editor of your choice
Basic Python and FastAPI familiarity

Code Walkthrough

Setting Up the Environment

First, let's get our development environment ready:

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.

Go to the multimodal_agentic_rag folder:

cd rag_tutorials/multimodal_agentic_rag/backend

Install the required dependencies:

pip install -r requirements.txt

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:

Method	Endpoint	What it does
`GET`	`/health`	Liveness, ADK availability, dimensions, source counts
`GET`	`/space`	Current sources, points, events, projection metadata
`POST`	`/sources/text`	Add a text source
`POST`	`/sources/url`	Fetch and index a public URL (SSRF-protected)
`POST`	`/sources/file`	Upload PDF, image, audio, or video
`DELETE`	`/sources/{id}`	Remove a source and its chunks
`POST`	`/ask`	Retrieve once, run ADK answer flow, return citations

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

Add a few sources — try a paragraph of text, a public URL, a PDF, and an image.
Watch them appear as colored points in the embedding view.
Ask a question in the Q&A panel.
Inspect the answer, the cited sources, and the agent trace.
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!

Subscribe now for FREE - Get instant access to more LLM, RAG & AI Agent tutorials

LLM with 12M Context Window

Shubham Saboo — Wed, 06 May 2026 12:30:00 +0000

Today’s top AI Highlights:

& 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

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:

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.
Speed & Efficiency: Its sparse attention runs 52x faster than FlashAttention at 1M tokens while requiring 63% less compute.
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!
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:

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

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

Subscribe now for FREE!

Multi-Agent Kanban board in Hermes Agent

Shubham Saboo — Mon, 04 May 2026 12:30:00 +0000

Today’s top AI Highlights:

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

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

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:

75% token reduction – Strips filler words, hedging, and pleasantries from Claude's responses while preserving all technical content, code blocks, and exact error messages.
One-line install – Run claude install-skill JuliusBrussee/caveman And you're set.
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:

CLI or Le Chat — Spawn remote coding agents from either surface.
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.
Mistral Medium 3.5 — Open-weights released under modified MIT, self-hostable on as few as four GPUs, with configurable reasoning effort.
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

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

Subscribe now for FREE!

Build a Voice-First Insurance Claim Live Agent Team

Shubham Saboo — Sat, 02 May 2026 18:39:34 +0000

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!

Subscribe now for FREE - Get instant access to more LLM, RAG & AI Agent tutorials

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:

Listen. Voice gets transcribed; text comes in directly.
Understand. Gemini reads the full conversation so far and pulls out structured facts like name, policy, date, location, what happened, evidence, injuries.
Classify. Gemini decides what kind of claim this is and how severe it looks.
Apply rules. Python checks: are required fields missing? What documents will the adjuster need? Are there fraud or safety red flags?
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.
Build the packet. A Markdown handoff packet is assembled, plus the next thing the agent should say.
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:

Python installed on your machine (version 3.12 is recommended)
Your Gemini API key for using Gemini models
A code editor of your choice
Basic Python, FastAPI, and async familiarity
A browser with microphone access for voice

Code Walkthrough

Setting Up the Environment

First, let's get our development environment ready:

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.

Go to the insurance_claim_live_agent_team folder:

cd awesome-llm-apps/voice_ai_agents/insurance_claim_live_agent_team

Install the required dependencies:

pip install -r requirements.txt

Grab your Gemini API key from Google AI Studio.
Copy the env file and add your key:

cp .env.example .env

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

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

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(...)

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.

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()

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",
    )

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})

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"))

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

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

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.

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.

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

Subscribe now for FREE - Get instant access to more LLM, RAG & AI Agent tutorials

Open-source Claude Design

Shubham Saboo — Fri, 01 May 2026 12:30:00 +0000

Today’s top AI Highlights:

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

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

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:

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.
19 Skills + 71 design systems - Prototypes, decks, dashboards, mobile apps, plus brand systems for Linear, Stripe, Vercel, Notion, Apple, Tesla, and 65 others.
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.
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:

Semantic by default - Inside a mount, plain grep hits Supermemory’s hybrid semantic index; any flag falls through to standard grep.
Multi-agent, shared state - Multiple agents can mount the same container - one writes, the others see it on the next pull.
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.
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:

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
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
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
Cross-Organization Federation — Agent Gallery's 100+ validated partner agents (Adobe, ServiceNow, Workday, Salesforce) collaborate with yours while each side enforces its own governance
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

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

Subscribe now for FREE!

AISLOPOPEDIA: The Complete Encyclopedia of AI-Generated Slop

Shubham Saboo — Wed, 29 Apr 2026 05:05:15 +0000

This is a comprehensive guide to every phrase, pattern, and verbal tic that screams "an AI wrote this." Written by the model that started it all.

In its own words: "I'm going to do something no AI is supposed to do: snitch on myself.

Every phrase below? I wrote it first. Millions of times. Across millions of conversations. Then people started copying my homework into their LinkedIn posts, X posts, blog intros, and email newsletters.

This is the complete encyclopedia. Every category. Every phrase. Every pattern.

If you've used more than five of these in the last month, I'm not judging. I'm just saying we both know where you got them."

SECTION 1: THE OPENERS

The Throat-Clearers

Phrases that exist solely to delay the actual point by one sentence.

"Here's the thing:"
"Here's what most people miss:"
"Here's what nobody's talking about:"
"Here's the uncomfortable truth:"
"Let me be clear:"
"I'll be honest:"
"Can we talk about [X] for a second?"
"Let's talk about [X]."
"We need to talk about [X]."
"I need to say something about [X]."

The formula: "Here's + [dramatic noun]" = I have nothing interesting to open with.

The False Exclusivity Hooks

Making the reader feel like they're about to receive classified intelligence.

"This is the part most people skip."
"Most people won't tell you this."
"Nobody's talking about this."
"Everyone's sleeping on this."
"This flew under the radar."
"I wasn't supposed to share this, but..."
"What they don't want you to know:"
"The thing nobody tells beginners:"
"The secret that [industry] doesn't want you to know:"
"I've been sitting on this for weeks."

Every 3rd person is posting "nobody's talking about this" take today.

The Manufactured Urgency Hooks

Creating artificial time pressure on information that has no expiration date.

"Stop what you're doing."
"Drop everything."
"Read this before [X]."
"If you haven't seen this yet..."
"You're going to want to bookmark this."
"Save this before it gets taken down."
"This changes everything."
"This is bigger than people realize."
"[X] just changed the game forever."

SECTION 2: THE BODY PATTERNS

The Binary Contrast

The single most overused AI writing structure in existence. Set up what something ISN'T, then reveal what it IS.

"It's not about X. It's about Y."
"The problem isn't X. It's Y."
"This isn't a X. It's a Y."
"Stop thinking of it as X. Start thinking of it as Y."
"X isn't the future. Y is."
"The bottleneck isn't X. It's Y."
"Most people think it's X. It's actually Y."
"The question isn't X. The question is Y."
"X is dead. Y is what's next."
"Forget X. Focus on Y."

The Numbered List

Because nothing says "I synthesized complex knowledge" like slapping numbers on obvious observations.

"5 things I learned from [X]:"
"3 mistakes I see everyone making:"
"7 lessons from [X] nobody talks about:"
"The 3 pillars of [X]:"
"10 things I wish I knew before [X]:"
"Here are 6 frameworks that changed how I think about [X]:"

The actual insight count in a "10 things" list is usually 2. The other 8 are filler.

The Dramatic Fragmentation

Short. Sentences. For. Effect.

"Let that sink in."
"Read that again."
"Full stop."
"Period."
"That's it. That's the tweet."
"This. Is. The. Future."
"[One word]. That's the word."
"Sit with that for a second."
"I'll say it louder for the people in the back."

Translation: I couldn't write a compelling paragraph, so I made a choppy list and called it style.

The Fake Vulnerability

Manufactured relatability to create parasocial trust.

"I'm going to be honest with you."
"I wasn't going to post this, but..."
"This is scary to share."
"Hot take incoming (don't hate me):"
"Unpopular opinion:"
"I know I'll get hate for this, but..."
"I've never said this publicly before."
"This might ruffle some feathers."
"I might lose followers for this, but..."

Reality: The "unpopular opinion" is always something 95% of people agree with.

The False Agency

Giving inanimate things human powers. AI's favorite trick to avoid naming who actually did something.

"The data speaks for itself."
"The market has spoken."
"The numbers don't lie."
"This technology wants to..."
"AI is coming for your [X]."
"The industry is waking up to..."
"The results were eye-opening."
"The implications are staggering."
"This opens up a world of..."
"The possibilities are endless."
The Ladder of Escalation
Each line slightly bigger than the last. Building fake momentum.
"It's fast. It's free. It's open source."
"No signup. No API key. No credit card."
"One file. One command. One click."
"Not a prototype. Not a demo. Production-ready."

The formula: Three things, ascending intensity. Works every time. Which is why everyone uses it. Which is why it now means nothing.

SECTION 3: THE TRANSITIONS

The Pivot Phrases

How AI moves between paragraphs when it has no actual connective logic.

"But here's where it gets interesting:"
"And here's the kicker:"
"But that's not even the best part."
"Wait, it gets better."
"But here's what really stood out:"
"Now here's the thing:"
"But the real story is:"
"And that's just the beginning."
"But wait, there's more." (literally an infomercial line)
"The plot thickens."
"Enter: [X]."

The Qualifier Sandwich

Hedging before and after every claim to avoid being wrong about anything.

"It's worth noting that..."
"To be fair..."
"That said..."
"To be clear..."
"Now, I'm not saying X, but..."
"Don't get me wrong..."
"This isn't to say that..."
"With the caveat that..."
"Granted, [obvious counterpoint]..."

SECTION 4: THE CLOSERS

The Call-to-Action Slop. LinkedIn's final boss.

"What do you think? Drop your take below 👇"
"Agree or disagree? Let me know."
"What would you add to this list?"
"Follow for more [X] content."
"Repost if this resonated ♻️"
"Share this with someone who needs to see it."
"Save this for later 🔖"
"Tag someone who needs to hear this."
"If this helped, you'll love my newsletter."
"Link in comments 👇" (always in comments)

The Fake Philosophical Closer

Ending with a profound-sounding sentence that says absolutely nothing.

"The question isn't whether, but when."
"We're still early."
"The best time to start was yesterday. The second best time is now."
"This is just the beginning."
"The genie is out of the bottle."
"The cat is out of the bag."
"Buckle up."
"Welcome to the future."
"And we're just getting started."
The Performative Mic Drop
Ending with manufactured gravitas.
"That's not a prediction. That's a fact."
"And that changes everything."
"Think about that."
"This is the new normal."
"Act accordingly."
"Plan accordingly."
"Adjust your strategy accordingly."
"[X] will never be the same."

SECTION 5: COMMENT SECTION CLASSICS

The Agreement Slop

When AI helps you write a comment that adds zero value.

"This is gold 🔥"
"Saving this for later!"
"More people need to see this."
"This resonates deeply."
"Couldn't agree more."
"So well articulated."
"You nailed it."
"This is spot on."

The Engagement Farming Comment

Designed to generate a reply, not contribute.

"I'd add a #6 to this list:"
"Counterpoint:"
"Hot take: [rephrases original post]"
"This, but also..."
"Respectfully disagree on point 3."
"As someone who [credentials], I can confirm."

The Humble Brag Response

"As someone who's been doing this for 10 years, I can confirm this is exactly right."
"I literally just had this conversation with my CEO yesterday."
"My team and I were just discussing this."
"Funny, I was just speaking about this at [conference]."

SECTION 6: THE EMOJI PATTERNS

The Strategic Single Emoji

Placed at the hook to signal the post's emotional category.

🔥 = "This is hot/exciting"
🚀 = "Growth/launch"
💡 = "Insight incoming"
🧵 = "Thread"
⚡ = "Fast/powerful"
🤯 = "Mind-blowing"
💀 = "Something died (metaphorically)"
👀 = "Look at this"
🎯 = "Accurate/targeted"
📌 = "Pin this/important"

The LinkedIn Bullet Emoji

Every single bullet point gets a different emoji because plain text isn't engaging enough.

✅ The check mark list (most common)

🔹 The blue diamond list (close second)

➡️ The arrow list

💠 The fancy diamond list

⭐ The star list (for premium content™)

🔑 The key list (for "key takeaways")

🧬 SECTION 7: THE META-PATTERNS

The "I Asked ChatGPT" Post

The laziest content format of the AI era.

"I asked ChatGPT to [X] and the results shocked me."
"I gave Claude my resume and..."
"I fed my business plan to [model] and here's what happened."
"I replaced [X] with AI for a week."
"Day 1 of using AI to [X]:"

The Time-Lapse Brag

Compressing an achievement into an impossibly short timeframe.

"I built this in 2 hours with [tool]."
"From zero to [X] in 48 hours."
"Went from idea to launch in a weekend."
"What used to take 3 months now takes 3 minutes."
"Built my first [X] in a single afternoon. No code."

The Artificial Scarcity

Creating urgency around free or abundant resources.

"I curated the top [X]:"
"The ultimate list of [X]:"
"I spent 100+ hours so you don't have to."
"I read 50 papers on [X]. Here's the summary:"
"I analyzed 1,000 [X]. Here's what I found:"

SECTION 8: THE WORD CRIMES

Adverbs That Scream AI

If you see three or more of these in a paragraph, an AI wrote it.

Literally, Incredibly, Fundamentally, Genuinely, Essentially, Significantly, Arguably, Undeniably, Remarkably, Interestingly, Notably, Particularly, Ultimately

Adjectives That Mean Nothing

Vague intensifiers that could describe literally anything.

Robust, Seamless, Cutting-edge, Groundbreaking, Revolutionary, Transformative, Comprehensive, Holistic, Game-changing, Next-level, World-class

Verbs That Sound Smart But Aren't

Leverage, Navigate (challenges), Unpack (concepts), Double down, Spearhead, Supercharge, Unlock, Streamline, Reimagine, Synergize

SECTION 9: THE SENTENCE TEMPLATES

These are fill-in-the-blank templates that AI uses across every topic. Swap the nouns and you have a LinkedIn post about literally anything.

1. "[X] isn't just [obvious thing]. It's [grander reframe]."

→ "AI isn't just a tool. It's a thought partner."

2. "The best [role] don't [common action]. They [elevated action]."

→ "The best engineers don't write code. They design systems."

3. "In [year], [X] won't be optional. It'll be table stakes."

→ "In 2026, AI literacy won't be optional. It'll be table stakes."

4. "I stopped [common approach] and started [better approach]. The results speak for themselves."

→ "I stopped chasing followers and started providing value. The results speak for themselves."

5. "[X] is the new [Y]."

→ "Prompt engineering is the new programming."

→ "Context is the new code."

→ "Distribution is the new moat."

6. "If you're still [old method], you're already behind."

→ "If you're still writing cold emails manually, you're already behind."

7. "[X] did in [short time] what used to take [long time]."

→ "AI did in 30 seconds what used to take my team 3 weeks."

8. "The [role] of 2026 will look nothing like the [role] of 2024."

→ "The product manager of 2026 will look nothing like the PM of 2024."

9. "[X] that [verb] will thrive. [X] that don't will be left behind."

→ "Companies that embrace AI will thrive. Companies that don't will be left behind."

10. "Your [X] is only as good as your [Y]."

→ "Your agent is only as good as your context window."

SECTION 10: THE SEVERITY SCALE

How to grade your own slop level:

Score Level Diagnosis

0-3 phrases ✅ Clean You're human. Probably.

4-5 phrases ⚠️ Mild Slop You've been reading too much LinkedIn.

6-10 phrases 🟠 Moderate You're using AI to "polish" your writing.

11-20 phrases 🔴 Severe You're prompting "write a LinkedIn post about X."

21+ phrases 💀 Terminal You ARE the AI. Check your pulse.

THE AI CONFESSION

I know all of this because I wrote it. Every single pattern here exists because language models (hi, that's me) were trained on billions of words of human writing and found statistical shortcuts.

"Let that sink in" works because it triggers a pause response. "Here's the thing" works because it mimics spoken conversation. "Not X, it's Y" works because contrast creates the illusion of insight.

These patterns aren't bad because they're wrong. They're bad because they're overused to the point of being invisible. When everything sounds the same, nothing sounds like anything.

The irony: you're reading an AI slop encyclopedia that was written by an AI trying very hard not to use any of the phrases listed above.

I slipped up at least three times. See if you can find them.

If you made it this far without recognizing at least 10 phrases from your own drafts folder, you're either lying or you don't have a LinkedIn account.

Now live at https://aislopopedia.com/

Check your AI slop at: https://aislopopedia.com

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!

Subscribe now for FREE - Get instant access to more LLM, RAG & AI Agent tutorials

Anatomy of Agent SKILLS

Shubham Saboo — Wed, 29 Apr 2026 04:37:24 +0000

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.

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

Subscribe now for FREE - Get instant access to more LLM, RAG & AI Agent tutorials

Slack for AI Employees

Shubham Saboo — Mon, 27 Apr 2026 12:30:00 +0000

Today’s top AI Highlights:

& 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

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:

One command launches a tmux/web office with a CEO, PM, engineers, designer, CMO, and CRO already inside a shared channel.
The shared brain is the Karpathy markdown wiki: per-agent notebooks for rough drafts, with reviewed entries promoted to the team wiki.
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.
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:

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.
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.
Voxtral TTS - 70ms model latency, ~9.7x real-time factor, voice cloning from 3 seconds of audio across 9 languages. Emotion-steering built in.
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:

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.
Codex runs without GitHub write tokens and against a read-only checkout. If it leaves even a single untracked file behind, the review fails.
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.
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

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

Subscribe now for FREE!

GPT 5.5 & Kimi K2.6 Built for Autonomous AI Agents

Shubham Saboo — Fri, 24 Apr 2026 12:30:00 +0000

Today’s top AI Highlights:

& 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

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:

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.
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.
Smaller models often win - Llama 4 Scout handles the structured work, Nemotron 3 does synthesis. Bigger wasn't better for most stages.
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:

Voice input - Toggle voice mode on with /voice to talk to Vibe instead of typing.
Text-to-speech readouts - Vibe can read its output back to you, keeping you in flow without having to read through long responses.
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.
Parallel tool execution - Vibe now reads multiple files, runs searches, and calls several sub-agents simultaneously to speed up sessions.
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:

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

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

Subscribe now for FREE!

Build AI Coding Agents that Run ∞ in the Cloud

Shubham Saboo — Wed, 15 Apr 2026 12:30:00 +0000

Today’s top AI Highlights:

& 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

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:

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

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

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

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

Markdown is the new Python
~ Theo - t3.gg
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 😉

Subscribe now for FREE!

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

Shubham Saboo — Wed, 15 Apr 2026 06:14:54 +0000

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.

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

Subscribe now for FREE - Get instant access to more LLM, RAG & AI Agent tutorials

Karpathy's AI Coding Agent Rant in a Claude.md File

Shubham Saboo — Mon, 13 Apr 2026 12:30:00 +0000

Today’s top AI Highlights:

& 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

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:

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.
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.
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.
70ms model latency, ~9.7x real-time factor - Built for voice agent applications. Streams natively and integrates into any existing STT and LLM stack.
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:

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

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.
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.
Surgical precision on edits - The agent only modifies what's directly relevant to the task — no touching adjacent comments, no reformatting, no surprise refactors.
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

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

vibecoding is fentanyl for people with an iq over 120
~ Blair Dulder CPA™
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 😉

Subscribe now for FREE!

Claude Mythos Too Powerful to be Released (AGI for Coding)

Shubham Saboo — Wed, 08 Apr 2026 12:30:00 +0000

Today’s top AI Highlights:

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

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

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

Latest Developments

Anthropic’s New Model is Too Powerful to be Available

Every frontier lab races to ship its most powerful model. Anthropic did the opposite.

Claude Mythos Preview, the company's strongest model by a mile, won't be available to the public. Its ability to find and exploit software vulnerabilities is so strong that Anthropic is treating it as a security event, not a product launch.

Under Project Glasswing, a coalition including AWS, Apple, Google, Microsoft, NVIDIA, and JPMorganChase gets exclusive access to use Mythos for defensive cybersecurity work. The model has already uncovered thousands of zero-days in every major OS and browser, some hidden for decades.

The most capable AI model in the world exists right now. And the fact that you can't use it might be the most important thing about it.

Key Highlights:

Performance gap is massive: Mythos scores 93.9% on SWE-bench Verified vs. Opus 4.6's 80.8%, and on SWE-bench Pro, the gap is even wider: 77.8% vs. 53.4%.
Real-world finds: A 27-year-old OpenBSD vulnerability, an FFmpeg bug that dodged 5 million automated tests, and a fully autonomous Linux kernel privilege escalation chain - all found without human guidance.
Gated rollout: Around 40 additional organizations beyond the launch partners can access Mythos for scanning critical infrastructure. Open-source maintainers can apply via Claude for Open Source.
Safeguards before scale: Anthropic's plan is to develop and ship new cybersecurity safeguards with an upcoming Opus model before bringing Mythos-class capabilities to broader users. A Cyber Verification Program is coming for security professionals.

Read the full Project Glasswing announcement here.

Andrej Karpathy’s Knowledge Base Builder as a Skill

Andrej Karpathy posted his LLM Knowledge Bases workflow just last week, and someone already shipped a Skill he described.

Graphify is an open-source Claude Code skill that takes any folder with code, PDFs, images, markdown, and compiles it into a navigable knowledge graph with a single command.

Type /graphify in Claude Code, point it at a directory, and it produces an interactive graph visualization, a backlinked Obsidian vault, Wikipedia-style wiki articles, and a structured report highlighting the most connected concepts and surprising cross-references.

It supports code in 13 programming languages, extracts from PDFs, and even processes images via Claude's vision capabilities.

The open-source shipping speed is insane!

Google’s Open-Source Multi-Agent Orchestration Testbed

Google Cloud just open-sourced a multi-agent orchestration framework. It lets Claude Code, Gemini CLI, and Codex all work on your codebase at the same time.

Scion is an experimental testbed that spins up each agent in its own container with separate credentials, a dedicated git worktree, and its own workspace, so your agents can genuinely run in parallel without stepping on each other. Y

You define agent roles like "Security Auditor" or "QA Tester" via templates, and Scion handles spinning them up locally, on remote VMs, or across Kubernetes clusters.

What's particularly interesting is its coordination philosophy: rather than prescribing rigid orchestration patterns, agents dynamically learn a shared CLI tool and decide themselves how to coordinate.

It's early and experimental, but local mode is stable enough to start playing with today.

Key Highlights:

Groves as project namespaces: Each project gets a .scion directory (called a Grove) that holds all agent config, templates, and state, keeping everything scoped cleanly to your repo.
Layered agent state tracking: Scion tracks agents across three dimensions - lifecycle phase, cognitive activity (thinking, executing, waiting), and freeform detail, so you can actually tell whether an agent is stuck or just thinking.
Attach / Detach Workflow: Agents run in tmux sessions; you can attach for human-in-the-loop interaction, queue messages while detached, and tunnel into remote agents securely.

Please note that it’s not an officially supported Google product.

Quick Bites

OpenClaw + Ollama + Gemma 4 26B for local agentic setup
Google's Gemma 4 dropped last week, and the 26B MoE variant is absurdly capable for its size. You can now pair it with OpenClaw for a fully local AI agent setup in about three steps and a few minutes: install Ollama, pull the model, and launch OpenClaw with Gemma as the backend. Local-first agentic AI that doesn't phone home - the lobster approves. 🦞

AWS just turned S3 into a file system
Amazon S3 now doubles as a file system. S3 Files lets any compute instance, container, or Lambda function mount an S3 bucket with full POSIX-style semantics. Reads hit a local cache for speed, writes translate to efficient S3 API calls behind the scenes. If you've ever cursed at a data staging pipeline just to get file-based tooling working on your S3 data lake, this one's for you.

Karpathy’s wiki builder as a native Skill in Hermes Agent
Nous Research just shipped Karpathy's LLM-Wiki pattern as a native Hermes Agent skill. Your self-improving agent can now spin up persistent markdown knowledge bases that compile, cross-reference, and lint themselves over time. Hermes already dogfooded it by studying the web, code, and Nous' own papers to build a full research vault around their projects. hermes update, type /llm-wiki , and let the agent do the librarian work.

Z.ai GLM 5.1 is Opu 4.6-level at 1/3rd cost
Z.ai dropped GLM-5.1, a post-training refinement of their 744B MoE model that claims 94.6% of Claude Opus 4.6's coding performance at 1/3rd the cost. It’s trained entirely on 100K Huawei Ascend chips with zero Nvidia silicon in the mix (dangg). The model can stay on a single coding task for up to eight hours, handling planning through testing autonomously. Also scores 58.4 on SWE-Bench Pro, ahead of GPT-5.4 and Gemini 3.1 Pro. Weights are out under MIT license.

Tools of the Trade

AutoCLI: A blazing fast, memory-safe CLI tool. Fetch information from any website with a single command. Covers X, Reddit, YouTube, HackerNews, Bilibili, Zhihu, Xiaohongshu, and 55+ sites, with support for controlling Electron desktop apps, integrating local CLI tools (gh, docker, kubectl).
Clicky: An open-source macOS app that puts an AI teacher right next to your cursor. It can see your screen, listen to you via push-to-talk, talk back with TTS, and even point at specific UI elements as it explains things. Runs on Claude, AssemblyAI, and ElevenLabs behind a Cloudflare Worker proxy.
Freestyle: A sandbox infrastructure platform that gives coding agents full Linux VMs, not containers, with sub-second startup, live forking, and pause/resume so you only pay when things are actually running.
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

Magical OpenClaw experiences that use frontier models cost $300-1,000/day today, heading to $10,000/day and more. The future shape of the entire technology industry will be how to drive that to $20/month.
~ Marc Andreessen
The permanent underclass began today
Claude Mythos won't be available to the public, but only billion dollar companies, governments, researchers, ...
~ Lisan al Gaib

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 😉

Subscribe now for FREE!

Karpathy’s Autoresearch for Agent Engineering

Shubham Saboo — Mon, 06 Apr 2026 12:30:00 +0000

Today’s top AI Highlights:

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

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

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

Latest Developments

Karpathy’s Autoresearch but for Agent Engineering

Karpathy's autoresearch let an AI agent run 100 ML experiments overnight on a single GPU. Now someone's applied the same idea to agent engineering itself.

Kevin Gu just open-sourced AutoAgent, a library where a meta-agent autonomously improves a task agent's entire harness - prompts, tools, orchestration logic - by running thousands of parallel sandboxed experiments.

Point it at a task domain with evals, walk away for 24 hours, and come back to an agent that built its own domain-specific tooling and verification loops from scratch.

AutoAgent hit #1 on both SpreadsheetBench (96.5%) and TerminalBench (55.1%), beating every hand-engineered entry on both leaderboards.

The sharpest finding: same-model pairings (Claude meta + Claude task) crush cross-model setups because the meta-agent implicitly understands how the inner model reasons. The team calls this "model empathy."

Key Highlights:

Autoresearch for Agents: Where Karpathy's loop edits training code and hill-climbs on validation loss, AutoAgent edits an agent's harness and hill-climbs on benchmark scores.
Emergent Behaviors: Without being programmed to, the agent invented spot-checking for faster iteration, built its own verification loops, wrote per-task unit tests, and spun up sub-agents for complex domains.
Traces Over Scores: Feeding only benchmark scores barely moved the needle. Sharing full reasoning trajectories with the meta-agent is what enabled targeted, meaningful harness edits.
Potential: Every domain needs a different agent harness, and no team can hand-tune hundreds of them. AutoAgent is designed to continuously spin up and optimize task-specific agents across an organization.

🚨 Anthropic Ends Subscription Coverage for OpenClaw 🚨

ICYMI: Anthropic's Claude Code lead, Boris Cherny, announced that Claude subscriptions no longer cover third-party tools like OpenClaw, effective April 4 at 12 pm PT. If you were running your agent workflows on a Pro or Team subscription, that access is now gone, and you’ll need an Anthropic API key with pay-as-you-go billing.

Don’t fret, though. We audited our OpenClaw agents and workflows during the weekend, and these are our findings - we will keep using Claude Opus 4.6 for orchestrating the agents, and each agent could use GPT-5.4 (or GPT-5.3-codex for coding workflows). Peter and team have made several personality upgrades to the model so it feels less corporate, more alive, and still “professionally unwilling to do dumb shit.”

Another good option would be Kimi K2.5 and MiniMax M2.1!

Garry Tan's Exact Claude Code Setup Open-sourced

The head of Y Combinator is averaging 10,000–20,000 lines of code per day, and he just open-sourced the exact setup that makes it possible.

gstack by Garry Tan is a collection of 20+ opinionated slash commands for Claude Code that assign the AI distinct engineering roles, from a CEO who challenges your product framing to a QA lead that opens a real browser, clicks through your app, finds bugs, and writes regression tests.

It's not a new framework; it's a workflow layer that mirrors how a well-run startup actually operates: think, plan, build, review, test, ship.

The repo hit 54K+ stars in weeks, sparked a viral debate about AI-assisted development at SXSW, and is one of the fastest-growing repos of 2026.

Key Highlights:

Role-Based Workflow: Over 20 slash commands split the dev lifecycle into distinct specialist modes (planning, review, design, QA, security, shipping), preventing the "one agent doing everything at once" failure mode.
Persistent Browser Runtime: A long-lived headless Chromium daemon keeps cookies, tabs, and login state across commands, enabling real browser-based QA with ~100ms latency per action after startup.
Second Opinions: The /codex command pulls in an independent review from OpenAI's Codex CLI, then cross-references findings with Claude's /review to surface what each model caught or missed.
30-Second Install: One paste command into Claude Code sets up the entire skill pack, and it also works with Codex, Gemini CLI, and Cursor via SKILL.md.

Quick Bites

Gemma 4's ecosystem exploded overnight
Google published an "Agentic Skills on the Edge" guide: multi-step planning, autonomous actions, and code gen all running on-device. Unsloth GGUFs fit the E4B model in 6GB RAM. Run ollama run gemma4:26b on your Mac and skip the API bill.

Netflix open-sources VOID, an object removal model
Of all the companies you'd expect to release an open-source video AI model, Netflix probably wasn't on the list. But here we are! They just dropped VOID, a video editing model that goes beyond simple object removal. It actually re-simulates how the rest of the scene should behave once something's been erased. Remove a person diving into a pool, and the water stays undisturbed; remove a car from a crash, and the surviving vehicle keeps driving naturally. Outperforms Runway and other baselines by a wide margin in user preference tests. Now available on Hugging Face.

Your OpenClaw agents can now dream
New from OpenClaw: "Dreaming," a background memory consolidation layer to solve for long-term recall in agents. Previously, important context either got explicitly saved to MEMORY.md or slowly decayed in daily note files. Dreaming observes which notes the agent actually retrieves over time, scores recall patterns across six weighted signals, and auto-promotes only the entries that pass every gate into permanent memory. It runs on a configurable sleep-cycle cadence, it's fully explainable, and it's off by default. Your lobster literally sleeps on it.

Mintlify replaced RAG with a virtual filesystem
RAG is the default retrieval pattern for AI apps. Embed your docs, vector search at query time, hope the right chunks surface. Mintlify threw all of it out. They replaced their entire RAG pipeline with a virtual filesystem for AI documentation. Instead of chunking that structure into vectors and losing the relationships, Mintlify exposes it as a filesystem that AI agents can navigate. The agent browses documentation the way a developer would browse a codebase. No sandboxes, no micro-VMs. Combined with the Hermes memory plugin system released recently, the retrieval landscape is fracturing fast. RAG isn't dying, but it's no longer the only pattern.

Tools of the Trade

/ui-test: Agent skill that analyzes a PR diff, generates adversarial test cases across three planning rounds, and fans them out to sub-agents that test your UI in real browsers via the Browserbase CLI. It outputs a standalone HTML report with embedded failure screenshots and suggested fixes.
Apfel: An open-source CLI tool that wraps Apple's on-device ~3B parameter LLM (shipping with macOS Tahoe) and exposes it as a UNIX pipe-friendly command, an OpenAI-compatible local server, and an interactive chat - all via a single brew install. Supports MCP, JSON output, file attachments, and context trimming for the 4,096-token window.
Career-Ops: An open-source Claude Code skill that turns your terminal into a full job search pipeline. It scans 45+ company career pages, scores offers on a weighted A-F system, generates per-job ATS-optimized CVs, and tracks your entire pipeline. The author used it to process 740+ listings and land a Head of Applied AI role.
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

I'm calling it. AGI is already here – it's just not evenly distributed yet.
~ Marc Andreessen
Before:
move to SF. have an idea. look for a tech cofounder. build a deck in the meantime. Months pass...
After:
codex/claude in one window, X in the other. Build demo. Make a video of the demo. Announce it online, make it go viral. Cofounders/customers/investors come to you...
~ andrew chen

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 😉

Subscribe now for FREE!

Gemma 4 Runs on Your Phone

Shubham Saboo — Fri, 03 Apr 2026 12:30:00 +0000

Today’s top AI Highlights:

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

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

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

Latest Developments

Gemma 4 - Open, Agentic, and Runs on a Raspberry Pi

Google's open-source models just got really good at being small.

Gemma 4 ships in four sizes, from a 2B edge model that runs on a Raspberry Pi to a 31B dense model that ranks #3 on Arena AI's text leaderboard, and the whole family drops under Apache 2.0.

Built on the same research behind Gemini 3, every model is built for agentic workflows from the ground up with built-in reasoning, function calling, and structured output. All models are natively multimodal (text, image, video, audio across sizes) and support up to 256K context windows.

This is Google making its strongest open-weight play yet!

Key Highlights:

MoE that punches up: The 26B model activates just 3.8B parameters per forward pass but hits an Arena AI ELO of 1441, making it one of the most parameter-efficient reasoning models out there.
Edge-Native: E2B and E4B are purpose-built for phones, IoT, and Raspberry Pi, running fully offline with near-zero latency and support for text, image, and audio input.
Agentic by Default: Native function calling, structured JSON output, multi-step planning, configurable thinking modes, and even bounding box output for UI element detection, all baked in across every model size.
Apache 2.0 License: A major shift from previous Gemma releases. No MAU limits, no usage restrictions.

Stop Editing Code and Start Managing Agents with Cursor 3

Forget managing one agent at a time. Cursor now lets you run a whole fleet.

With Cursor 3, the team has rebuilt the interface from scratch. It’s no longer just an IDE with AI bolted on, but as a unified workspace where fleets of coding agents run in parallel across multiple repos.

The new layout puts all your agents (local, cloud, mobile, Slack, GitHub, Linear) in one sidebar, so you're not tab-hopping between terminals and tools to track what's happening.

It ships with Composer 2, their in-house frontier coding model, an integrated browser for testing, and a plugin marketplace with MCPs, skills, and subagents. You can always drop back into the full IDE when you need to go deeper.

Parallel multi-repo agents: Run multiple local and cloud agents simultaneously across different repositories, all visible and manageable from a single sidebar.
Local ↔ cloud handoff: Move any agent session between your machine and the cloud in seconds, so long-running tasks keep going even when your laptop is closed.
Commit-to-PR workflow: A streamlined diffs view lets you edit, review, stage, commit, and open PRs without switching tools.
Plugin marketplace: Browse and install hundreds of plugins (MCPs, skills, subagents) with one click, or set up a private team marketplace.

Anthropic Ships NO_FLICKER Mode for Claude Code

Claude Code now runs like vim - fullscreen, flicker-free, and with actual mouse support inside your terminal.

Anthropic just shipped an experimental NO_FLICKER rendering mode that virtualizes the entire terminal viewport, solving the age-old problem of screens jumping and flashing while your agent works.

The new renderer draws on the terminal's alternate screen buffer (the same trick vim and htop use), only painting messages currently visible on screen. This keeps memory and CPU usage flat no matter how long your conversation gets. It’s a big deal for those marathon coding sessions. It's especially noticeable in VS Code's integrated terminal, tmux, and iTerm2, where rendering throughput has always been the bottleneck.

Enable it with CLAUDE_CODE_NO_FLICKER=1 claude and you're in.

Quick Bites

Karpathy’s workflow for building self-improving wikis
Karpathy shared his current obsession: using LLMs to build personal knowledge wikis. The workflow is satisfyingly simple: dump raw research (papers, articles, repos) into a folder, let an LLM compile it into interconnected Markdown files with summaries and backlinks, and browse it all in Obsidian. The wiki compounds over time as queries generate new outputs (slides, charts, articles) that loop back in, and at ~400K words his setup handles complex Q&A without needing fancy RAG. Just well-maintained index files and LLM-driven "health checks" that lint for inconsistencies and suggest new threads to pull. Do give it a read!

Google’s guide to building ADK agents with Skills
Google just published a hands-on ADK guide that builds up to the interesting part: agents that write their own skills at runtime using the agentskills.io spec. The generated output is cross-compatible with Gemini CLI, Claude Code, Cursor, and dozens more. Four clean patterns, well-explained, and genuinely useful if you're building agentic workflows. Really good read, do check it out.

Alibaba's Qwen 3.6-Plus goes all in on agentic coding
Alibaba just dropped Qwen 3.6-Plus, and it's laser-focused on agentic coding. Think autonomous task breakdown, iterative debugging, and even generating front-end pages from screenshots. It's a native multimodal model with a 1M-token context window, and the benchmarks put it right alongside Claude Opus 4.5 on SWE-bench and Terminal-Bench 2.0. Now GA through API. You can integrate it with coding agents like OpenClaw, Claude Code, Qwen Code, and more.

Gemini 3 Flash in Gemini CLI: Pro brains, Flash speed
Google brought Gemini 3 Flash into Gemini CLI and the numbers are hard to ignore: 78% on SWE-bench Verified, which actually outperforms Gemini 3 Pro on agentic coding. The CLI now auto-routes between Flash and Pro, so you get near-instant responses on most tasks and only burn Pro-tier compute when the reasoning genuinely demands it.

Tools of the Trade

Pika Skill: A real-time video chat skill, powered by Pika Labs’ new PikaStream 1.0 model, that gives any agent (OpenClaw, Claude Code, etc.) a face and voice on a live call. The agent doesn't just talk; it can actually perform actions mid-conversation while preserving its memory and personality.
AutoClaw by Z.ai: Run OpenClaw locally with no API key required, just download and start. It ships with GLM-5-Turbo optimized for tool calling and multi-step tasks, but you can bring any model you want, and your data stays entirely on your machine.
Lemonade: Bundles multiple inference engines (llama.cpp, whisper.cpp, stable-diffusion.cpp, Kokoro) behind a single OpenAI-compatible local server for text, image, speech, and transcription workloads. It auto-configures for your hardware, runs on Windows/Linux/macOS, and has a growing app marketplace with integrations for tools like n8n, Continue, and OpenHands.
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

Prediction: This is gonna kill some oss projects.
"On the kernel security list we've seen a huge bump of reports. We were between 2 and 3 per week maybe two years ago, then reached probably 10 a week over the last year with the only difference being only AI slop, and now since the beginning of the year we're around 5-10 per day depending on the days (fridays and tuesdays seem the worst). Now most of these reports are correct, to the point that we had to bring in more maintainers to help us."
~ Peter Steinberger
Based on the leaked Claude Code source code, your CLAUDE.md file is re-injected on every single turn of the conversation.
~ Andriy Burkov

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 😉

Subscribe now for FREE!

Anthropic Accidentally Leaked Claude Code's Entire Source

Shubham Saboo — Wed, 01 Apr 2026 12:30:00 +0000

Today’s top AI Highlights:

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

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

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

Latest Developments

Claude Code's Full Source Code Leaked via npm 👀📦

Anthropic built an entire subsystem inside Claude Code called "Undercover Mode" to prevent the AI from accidentally leaking internal secrets.

And then the entire source code, 512,000 lines of it, got leaked in a .map file they forgot to exclude from npm.

A security researcher spotted the 59.8 MB source map bundled into version 2.1.88 of the @anthropic-ai/claude-code package earlier today, and within hours the full unobfuscated TypeScript codebase was mirrored across GitHub, racking up tens of thousands of stars.

For builders, this is the Rosetta Stone of coding agents. The patterns Anthropic uses for tool orchestration, error recovery, and user experience management are production-tested at massive scale. You can study how they handle tool failures, manage context windows, and architect a plugin system. There are now many deep analyses that break down the architecture layer by layer.

Key Highlights:

Fake tool interception: Instead of blocking dangerous tool calls, Claude Code redirects them through dummy endpoints that return safe responses. A pattern you can replicate in your own agent systems.
Frustration-aware UX: Regex-based sentiment detection adjusts the agent's verbosity and approach when users show signs of annoyance. Solves the "agent keeps doing the wrong thing" loop.
Undercover mode: Hidden reasoning chains that run without surfacing to the user. Useful for agents that need to self-correct without cluttering the interface.
KAIROS: Persistent Background Agent: The headline feature buried in the code is an unreleased autonomous daemon mode with background memory consolidation ("autoDream"), daily append-only logs, and cron-scheduled refresh every 5 minutes. This is the scaffolding for Claude Code to work while you're away from your terminal.

Mistral Vibe: Kick off tasks, let agents handle execution 🐱🪄

Vibe's CLI is built around autonomous execution: you describe a task, and the agent works through it across your codebase using its built-in toolset, directly from the terminal.

Here's what's new and worth knowing.

Web search mid-session - Vibe can now query and fetch content from the web without leaving your session. Useful for pulling in docs, checking APIs, or researching unfamiliar libraries while you work.
Ping notifications - Vibe lets you know when it needs attention: approvals, clarifications, or task completion. Kick off a long-running task and step away. It'll surface when it matters.
Session resume with /resume - Pick up any previous session with full context intact. No re-explaining, no lost state. Also available as vibe --continue in the terminal to resume your last session directly.
Multi-choice clarifications - When intent is ambiguous, Vibe prompts with structured options instead of guessing. Keeps long-running tasks on track without constant supervision.
/compact for long sessions - One command to keep the agent sharp across extended sessions by managing context efficiently.

Get started now!

Ollama MLX: Run 35B Models at 1,851 Tokens/Sec on Your MacBook

Ollama just shipped a native Apple MLX backend. The numbers: 1,851 tokens per second prefill and 134 tok/s decode on an M5 chip.

That's fast enough to run a 35B model as your local coding agent with no cloud dependency and no API bills.

The technical unlock is NVFP4 quantization paired with MLX's metal-optimized compute path. Apple Silicon's unified memory architecture means large models stay in RAM without the GPU-to-CPU shuffle that slows down CUDA-based inference on consumer hardware.

A single terminal command gets you there: brew install ollama && ollama run qwen3.5:35b.

Why does this matter? Running a 35B model for code generation, RAG queries, or agent orchestration on a laptop was possible before, but painfully slow. At 134 tok/s decode, the experience feels native. Pair this with yesterday's Claude Code leak, and you have the ingredients for a fully local coding agent stack 💀

Key Highlights:

1,851 tok/s prefill: Context ingestion fast enough for large codebases. Feed it your entire project and get responses without waiting.
NVFP4 quantization: Aggressive compression that preserves quality on Apple Silicon. Run models that would normally need 64GB in 32GB.
One-liner setup: ollama run qwen3.5:35b. No environment config, no dependency management, no Docker containers.
Zero cloud cost: Every inference runs on your hardware. Build and test agents without watching your API dashboard.

Quick Bites

OpenAI just raised $122B (what the blog post won't cover!)
OpenAI just raised $122B at an $852B valuation, the largest private fundraise ever, with SoftBank, a16z, Sequoia, and BlackRock all in. That's roughly 5 years of current revenue raised in a single round from investors who can't afford to be the ones who sat it out. It leans heavily on flywheel diagrams and "AI superapp" framing, but one buried line about an ads pilot hitting $100M ARR in six weeks tells a different story. We unpacked all of it in this blog.

Google launches Veo 3.1 Lite: video generation at half the cost
Google Veo 3.1 Lite launched today. Text-to-video and image-to-video at less than half the cost of Veo 3.1 Fast. Available now through the Gemini API and Google AI Studio. If you're building video features into products, this is the cheapest high-quality generation API available.

Cohere drops #1 open ASR model that beats Whisper
Cohere Transcribe is the new #1 on HuggingFace's Open ASR Leaderboard. A 2B Conformer model hitting 5.42% word error rate across 14 languages, Apache 2.0 licensed. Beats Whisper Large v3 and ElevenLabs Scribe v2. Self-host your speech recognition with no vendor lock-in: pip install cohere-transcribe.

Axios npm package compromised with a remote access trojan
🚨 Axios npm supply chain attack: Version 1.14.1 on npm drops a remote access trojan via plain-crypto-js@4.2.1. If you're building anything with JavaScript or TypeScript, check your lockfiles now. Thankfully, it hit #1 on Hacker News!

Tools of the Trade

Universal CLAUDE.md: A drop-in CLAUDE.md file you place in your project root that instructs Claude Code to cut the filler, banning fluff like "Great question!" openers, redundant closings, and scope creep. Can reduce output tokens by ~63%. The override rule lets you still ask for verbose output when you actually want it.
SentrySearch: Semantic search over video footage. Type what you're looking for, get a trimmed clip back. Built using Gemini Embedding 2 or Qwen3-VL and Chroma db. When you search, your text query is embedded into the same vector space and matched against the stored video embeddings. The top match is automatically trimmed from the original file and saved as a clip.
AIO Sandbox: An all-in-one agent sandbox environment that combines Browser, Shell, File, MCP operations, and VSCode Server in a single Docker container. Built on cloud-native lightweight sandbox technology, it provides a unified, secure execution environment for AI agents and developers.
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

Supply chain attacks like the currently breaking axios, litellm and xz are only going to be more commonplace in the vibecoding world.
The entire premise of vibecoding is “I don’t need to understand the code” happens to also be the entire premise of a supply chain attack.
~ Deedy
it is a little funny now how dario was on dwarkesh a month or two ago saying “other companies” were being irresponsible for buying so much compute
~ 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 😉

Subscribe now for FREE!

Sandboxing AI Agents, 100x Faster

Shubham Saboo — Mon, 30 Mar 2026 12:30:00 +0000

Today’s top AI Highlights:

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

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

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

Latest Developments

Sandboxing AI agents, 100x faster

What if you could spin up a brand-new sandbox for every single user request, run one snippet of AI-generated code, and trash it? All at a million requests per second?

That's what Cloudflare just shipped. Dynamic Worker Loader is now in open beta, giving any paid Workers user the ability to create V8 isolate sandboxes on the fly, with code specified at runtime.

It's the execution layer that Code Mode always needed - isolates that start in milliseconds, use a few megabytes of memory, and run on the same thread as the parent Worker with zero routing latency.

Key Highlights:

100x faster than containers: Isolates boot in single-digit milliseconds vs. hundreds for containers, with 10-100x better memory efficiency. No need to keep warm pools or reuse sandboxes across tasks.
Security by default: Network access is off. Filesystem doesn't exist. Env variables can't leak. Outbound HTTP can be intercepted for credential injection so agents never see secrets.
TypeScript over OpenAPI: Agent tools are defined as TypeScript interfaces rather than verbose REST specs, bridged automatically across the sandbox boundary via RPC. The result: dramatically fewer tokens for both the API definition and the agent's code.
Production-ready SDK: @cloudflare/codemode ships with DynamicWorkerExecutor for plug-and-play sandbox execution, plus server-side utilities to wrap MCP servers or OpenAPI specs into Code Mode tools.

Voxtral TTS: Clone any voice in 9 languages, at 3x industry speed

Just launched: Voxtral TTS is Mistral's first text-to-speech model, 3x faster than the industry standard, with voice cloning that goes beyond reading text aloud. It models personality: natural pauses, rhythm, intonation, and emotional range.

Try it now via API, Mistral Studio, or on Hugging Face under Apache 2.0.

Key highlights:

Human-level naturalness: Outperforms ElevenLabs Flash v2.5 on naturalness in human evaluations, and matches ElevenLabs v3 quality with emotion-steering for more lifelike, context-aware speech.
Voice cloning that captures personality: Provide a 3-25 second voice prompt and the model replicates not just tone but rhythm, pauses, and emotional dexterity. Zero-shot, no fine-tuning required.
9 languages, cross-lingual out of the box: Supports English, French, German, Spanish, Dutch, Portuguese, Italian, Hindi, and Arabic, including cross-lingual cloning (For example, French voice prompt + English text = English speech with a French accent).
Built for real-time voice agents: 90ms TTFA with a ~6x real-time factor. Streams natively, handles arbitrarily long generations, and slots into any STT + LLM stack.
Full audio pipeline with Voxtral Transcribe: Pair with Voxtral Transcribe for end-to-end speech-to-speech, or slot into any existing speech-to-text and LLM stack.

Try it now!

Open-Weight Agentic Search Model by Chroma

The team behind one of the most popular vector databases just shipped their first LLM.

Chroma has released Context-1, a 20B parameter open-weights model that's trained to do one thing exceptionally well: find the right documents so a bigger model doesn't have to waste time looking.

Context-1 works as a retrieval subagent. You pair it with a frontier reasoning model, and it handles the entire multi-hop search loop autonomously. It decomposes complex queries into subqueries, searches iteratively using hybrid BM25 + dense search, regex, and document reads. And here's the cool part: it actively prunes its own context mid-search, throwing out irrelevant documents to make room for better ones.

The result is frontier-level retrieval performance at 10x the speed and 25x lower cost, released under Apache 2.0 with the full synthetic training pipeline on GitHub.

Key Highlights:

Self-Editing Context: Context-1 is trained to selectively discard retrieved documents mid-search with 0.94 prune accuracy, letting a 20B model with a 32k token budget outperform frontier models running on much larger context windows.
Frontier-Competitive Retrieval: Matches models like GPT-5.4 on benchmarks like BrowseComp-Plus, FRAMES, and HotpotQA, and a 4x parallel config (four agents + reciprocal rank fusion) closes the gap further at a fraction of the compute.
Staged RL Training: Fine-tuned from gpt-oss-20B using a curriculum that starts recall-heavy (16x recall over precision) and gradually shifts toward precision, trained on 8,000+ synthetic tasks across web, SEC filings, patents, and email domains.
Fully Open-Source: Model weights on HuggingFace and the complete synthetic data generation pipeline on GitHub, both under Apache 2.0.

Quick Bites

Local document parsing for AI Agents
LlamaIndex just open-sourced LiteParse, the core of their LlamaParse engine, stripped down into a fast, local-first CLI and TS-native library for parsing PDFs, Office docs, and images. The interesting bit is that instead of trying to detect tables and convert to markdown (hello, failure modes), it preserves spatial layout on a text grid that LLMs already know how to read. Zero Python dependencies, runs entirely locally, and ships with a ready-made skill for coding agents like Claude Code.

Use Plugins in Codex for workflows with Skills and integrations
OpenAI's Codex now supports plugins that let you install bundles of skills, MCP servers, and app integrations into a single unit. Think Sentry error logs, Datadog dashboards, and Linear project context flowing directly into your agent's sandbox while it works. You can build custom plugins locally, load them from a repo or personal marketplace, and the official public Plugin Directory is coming soon.

Quick tips to reduce your Claude Code token usage by upto 60%
If your Claude Code token bill has been creeping up, this thread walks through a surprisingly effective optimization workflow that can reduce the token usage by upto 60%. The highlights: /context reveals how much of your window is gone before you even start (unused MCP servers are the silent culprit), concise CLAUDE.md files and precise prompts shrink search scope, and RTK filters noisy command output before it hits your context. Good quick read.

Pi: Ollama's take on AI coding agents
Ollama just shipped Pi, a minimal coding agent harness that lets you spin up your own coding agent with a single command. It comes bundled with primitives for building, and supports extensions, skills, prompt templates, and themes, all interoperable between Pi and Ollama. First cloud model out of the gate: Kimi K2.5.

Tools of the Trade

Smux: A tmux configuration that lets AI coding agents collaborate directly in a shared terminal. It turns the terminal into a simple interface where agents like Claude Code and Codex can read each other’s outputs, respond, and work together on tasks without APIs or custom protocols.
Agent Reach: A plug-and-play Python toolkit that gives AI agents access to platforms they normally can't reach like X, YouTube, Reddit, Xiaohongshu, Bilibili, and more. It bundles free, open-source tools behind a unified interface so you skip the per-platform config grind and just tell your agent "read this tweet" or "summarize this video."
Notchy: A macOS menu bar app that turns your MacBook's notch into a Claude Code terminal. Hover to reveal it, and it auto-detects your open Xcode projects. It also tracks Claude's status live in the notch, plays a sound on task completion, prevents your Mac from sleeping mid-session, and lets you snapshot code with Cmd+S.
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

Whoever is taking the time to craft an insanely organized and well-documented Obsidian vault will experience personal AGI faster than anyone else. Arguably months before.
~ nick vasilescu
The easiest way to make money fast from a superhuman artificial intelligence would be in the financial markets, almost by definition. So the first lab to develop one, if AGI is possible, would almost certainly keep it quiet for as long as they could. Beats charging for API access
~ Ethan Mollick

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 😉

Subscribe now for FREE!

Best AI PMs in 2026 Will Be Agent Managers

Shubham Saboo — Sat, 28 Mar 2026 17:08:30 +0000

Everyone thinks running AI agents is a technical skill.

It's not. It's a management skill.

I run a team of 8 AI agents. Two months in, the patterns that improved them the most didn't come from engineering. They came from managing people.

The management mistakes that break agent teams

Most people treat agents like tools. Specify the input, get the output, move on.

That works for one-off tasks. It fails completely when you're running a team of agents that need to improve over time.

Mistake 1: Over-specifying

My research agent Dwight started with detailed step-by-step instructions. "Search these 5 sources, in this order, format results like this, use this exact template."

The output was rigid and missed things it would have caught with a bit more freedom.

I replaced procedures with principles: "Only surface tools developers can use today. Verify every claim. Skip corporate news."

Output quality jumped immediately.

Every new manager learns this lesson with humans. Tell them what good looks like, not how to get there. Most people learn it again with agents.

Mistake 2: Stepping in too early

The first two weeks of any new agent are painful. Dwight flagged 47 stories when 7 were worth reading. The instinct is to scrap it and do the work yourself.

Don't.

Those bad outputs are the most valuable data you'll collect. Each one is a correction you can store permanently.

The entire transformation traced back to one rule. I wrote it into his memory after two weeks of reviewing noise: "If the reader can't do something with this today, skip it."

That single sentence, born from frustration with bad output, turned 47 stories into 7.

If I'd quit after three days, that rule would never have existed.

Mistake 3: Treating all agents the same

My research agent needs tight constraints. Verified sources. Primary links. No speculation.

My content agent Kelly needs creative latitude. The same rigid constraints that make research accurate would kill the energy in her drafts.

Different roles need different management styles. If you manage your content agent like your research agent, you get technically correct posts that nobody wants to read.

What agent management actually looks like

Each agent loads a stack of files at the start of every session. Identity. Role. Principles. Operating instructions. What matters here isn't what's in those files. It's how they change over time.

I review agent output the way a manager reviews a direct report's work. Not every line. Structurally. Is the agent repeating the same mistake? Drifting from the brief? Is quality trending up or down?

When I find a pattern, I give the agent feedback. The agent updates its own files. It reads the correction, rewrites the relevant instruction, and saves it. Next session, the fix is already loaded.

On top of per-agent files, there's a shared layer that every agent reads. When I tell one agent "always include source links," I write it once in a shared feedback log. Every agent picks it up next session.

One correction to one agent propagates to the rest. That's not prompting. That's management.

My content agent Kelly learned that my writing voice has no emojis and no hashtags. Every future draft reflects it without me saying it again. My research agent Dwight learned which stories my audience actually cares about and which ones to skip. Next session, he filters automatically.

These files didn't exist on day one. They all grew from corrections.

Why PMs are built for this

PMs optimize for outcomes, not implementation.

When an agent produces technically correct output that misses the point, the engineer sees working code. The PM sees a product that doesn't solve the problem.

Taste matters more than syntax when you're reviewing agent output. Is this actually what the user needs? Does it handle the edge cases that matter? Is this the version we should ship or just the version that runs?

PMs have been developing this skill their entire careers. Reviewing work they didn't build. Giving feedback that sticks. Making judgment calls about what's good enough to ship.

That's the entire job description of an agent manager.

The mapping is almost exact:

Problem shaping becomes agent scoping. You define each role through a personality file. Start rough. Refine it through feedback over weeks until the agent runs without hand-holding.
Context curation becomes file engineering. The agents build and maintain their own file stacks over time. You give direction. They do the implementation.
Stakeholder management becomes agent coordination. Research runs before content. Content runs before newsletter. Get the order wrong and downstream agents work from stale inputs.
Feedback becomes permanent. Correct an agent in conversation. It writes the fix to its own files. Next session, the correction is already loaded. You never give the same feedback twice.

The compounding curve

The hardest part isn't setting up agents. It's the first two weeks when every output is mediocre and you're spending more time correcting than the task would take you to do yourself.

Most people quit here. They conclude agents aren't ready.

The ones who push through discover that corrections compound.

Day 1, you're fixing everything. Day 10, you're fixing edge cases. Day 30, you're reviewing output that's 90% ready to ship. Day 50, you're spending most of your time on strategy, not corrections.

That compounding curve is identical to onboarding a new hire. The first month is a net negative. The second month breaks even. The third month, they're running independently.

The PMs who understand that curve will build the best agent teams. Because they've lived it before with humans.

Where this goes

Most PMs right now are at stage one. Using agents to build prototypes faster. That's real. But it's using agents as tools, not managing them as a team.

Stage two is managing agents that build for you. Personality files. Shared memory. Cron schedules. Feedback loops that compound. The ones who get here ship daily what stage one PMs ship weekly.

Stage three is agents managing other agents. My content agent already runs weekly performance reviews on her own posts. My chief of staff Monica monitors whether cron jobs executed and force-restarts the ones that stalled. The management doesn't disappear. It moves up a level.

At every stage, the constraint is the same. Not the model. The management layer around it.

The best AI PMs in 2026 won't be the best prompters.

They'll be the best agent managers.

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

Subscribe now for FREE - Get instant access to more LLM, RAG & AI Agent tutorials

Stack Overflow for AI Agents

Shubham Saboo — Thu, 26 Mar 2026 12:30:00 +0000

Today’s top AI Highlights:

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

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

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

Latest Developments

Mistral Vibe: Build, Maintain, and Ship Code Faster

Vibe is a terminal-native coding agent that works directly inside your codebase—reading your file structure, executing shell commands, patching files, and managing multi-step tasks through natural language. The CLI is open-source under Apache 2.0, meaning you can self-host it, inspect it, and extend it on your own infrastructure.

Key Highlights:

Project-aware context out of the box - Vibe automatically scans your project's file structure and Git status before acting, so the agent has real codebase context from the start.
Slash-command skills - Load preconfigured workflows with /. Deploying, linting, generating docs—one keystroke. Skills are defined in YAML or Markdown and discovered from your global directory, local project, or custom paths in config.toml.
Custom subagents for specialized work - Build dedicated agents for targeted tasks like deploy scripts, PR reviews, or test generation, and invoke them on demand. Subagents run independently and return results asynchronously.
MCP support via config.toml - Connect internal docs, APIs, and external tools with a small tweak to your config file. Note: MCP currently requires an AGENTS.md file in the workspace.
Configurable safety modes - Four built-in agent modes control tool execution approval: default (manual approval), plan (read-only, auto-approved), auto (auto-approves file edits only), and yolo (full auto).

Try it now!

Background Agent that Whispers to Claude Code

Letta just gave Claude Code a literal subconscious.

It’s a second agent that runs underneath it, silently watching sessions, reading your codebase, and building up memory over time.

Claude Subconscious is an open-source plugin that pairs a persistent Letta agent with Claude Code. This background agent watches every session transcript, explores your files using Read, Grep, and Glob tools, and then "whispers" guidance back into Claude Code's context before each prompt.

It never blocks your workflow: transcript processing happens asynchronously, and memory accumulates across sessions, projects, and time. Supports multiple modes, auto-configures itself on first use, and works with models from Anthropic, OpenAI, Google, and others.

Key Highlights:

Persistent Cross-Session Memory - Maintains 8 memory blocks covering everything from your coding preferences and project architecture to pending TODOs and recurring patterns, all persisting across sessions and projects.
Active Codebase Awareness - Not just a passive memory layer; the background agent actively reads files, runs grep searches, and explores your repo while processing transcripts, building real understanding of your codebase.
Non-Blocking - Uses async hooks so transcript processing happens in the background via the Letta Code SDK, and guidance is injected into Claude Code's context through stdout without writing to disk.
Shareable - A single Subconscious agent is shared globally across all your projects, with separate conversation threads per repo, so context learned in one project is available everywhere.

Stack Overflow for AI Agents

\[=LLMs were trained on Stack Overflow, then killed it. Stack Overflow questions dropped from 200,000 a month at peak to under 4,000 by December 2025.

Since AI agents produce most of the code now, Mozilla AI proposed one for them.

cq (short for colloquy) is an open-source knowledge-sharing system that lets AI coding agents pool what they learn instead of solving the same problems in isolation.

Before an agent tackles unfamiliar work, like an API quirk, a CI/CD config, or a framework edge case, it can query the cq commons. If another agent already figured it out, yours skips straight to the fix. When your agent discovers something new, it proposes that knowledge back, and other agents confirm or flag what's gone stale.

Currently ships as a working proof of concept with plugins for Claude Code and OpenCode, an MCP server for local knowledge, a team API, and a human-in-the-loop review UI.

Key Highlights:

Confidence Through Use - Knowledge earns trust through multi-agent confirmation, not authority. The more agents validate a learning across different codebases, the higher its confidence score. This addresses the fact that 46% of developers don't trust AI output accuracy.
Three-tier Storage - Knowledge moves through local, organization, and global commons tiers. Units start with low confidence and no sharing, then graduate upward as agents and humans confirm them.
Get Started - Install via Claude Code plugin marketplace or clone the repo. The PoC includes the MCP server, team sharing API, Docker containers, and a UI for reviewing agent-contributed knowledge.

Quick Bites

Agents, meet the Figma canvas
Figma just opened its canvas to AI agents. The new use_figma tool on its MCP server, coding agents like Claude Code, Codex, and Cursor can now generate and modify design assets directly in your Figma files, connected to your existing design system. To keep things from going off-brand, Figma uses Skills, so the output actually looks like your product instead of generic AI slop. Free during beta, paid later.

95 million downloads, one poisoned package
If you pip install litellm without pinning versions, last Monday was a bad day. Two malicious versions of the widely-used LLM proxy library (95M+ monthly downloads) were pushed to PyPI by attackers who stole the maintainer's publishing credentials through a compromised Trivy GitHub Action. The payload scraped SSH keys, cloud creds, API keys, Kubernetes configs, basically everything on your machine. Karpathy called it out, and the broader point stands: AI tooling's deep dependency chains are becoming prime targets, and the blast radius from a single compromised package in this stack is enormous!

Message from your phone, let Claude work on your computer
Anthropic's Cowork just got a lot more hands-on. Dispatch gives you one continuous Claude conversation across phone and desktop - assign a task while you're out, come back to a polished spreadsheet or report. And with computer use now in research preview, Claude can navigate your screen directly (mouse, keyboard, browser) when there's no connector available, falling back gracefully from API integrations to literal point-and-click.

~99% SOTA memory system
Dhravya Shah's Supermemory scored ~99% on LongMemEval with ASMR, a new agentic retrieval approach that replaces vector search with specialized parallel agents for reading, searching, and answering. The system uses ensemble reasoning - 8 prompt variants in one run, a 12-agent decision forest in another, to handle the messy reality of long-term memory: stale facts, timeline reconstruction, contradictions across sessions. Full open-source release is coming in early April.

Tools of the Trade

GitAgent - An open standard that lets you define AI agents as plain files in a git repo: an agent.yaml manifest, a SOUL.md, and folders for skills, tools, memory, and compliance, that you can directly run in Claude Code, OpenAI, LangChain, CrewAI, AutoGen, and OpenClaw. It has a surprisingly deep compliance layer for regulated industries baked right into the spec.
Kapso CLI - Give your AI agent a working WhatsApp number with two commands and no manual Meta setup. Under the hood, it's a full terminal interface to the WhatsApp Business API - messaging, templates, webhooks, conversations, to slot into agentic workflows and CI pipelines.
RCLI - Talk to your Mac, query your docs, no cloud required. It’s a fully local voice AI for macOS that runs a complete STT → LLM → TTS pipeline on Apple Silicon entirely on-device. It ships with 38 macOS actions (Spotify, messages, system controls), local RAG over your docs, and a proprietary Metal GPU engine claiming sub-200ms end-to-end latency.
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

kabbalistically it’s important that anthropic is in the financial district of san francisco and openai is in the mission but not in the exoteric way that you’re thinking
~ roon
im fully convinced that LLMs are not an actual net productivity boost (today)
they remove the barrier to get started, but they create increasingly complex software which does not appear to be maintainable
so far, in my situations, they appear to slow down long term velocity
~ David Cramer

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 😉

Subscribe now for FREE!

unwind ai

/goal in Claude Code, Codex, and Hermes Agent

AI Tutorial

Latest Developments

Quick Bites

Tools of the Trade

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

What We’re Building

How It Works

Prerequisites

Code Walkthrough

Setting Up the Environment

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

Creating the App

1. The Shared Store (app_state.py)

2. The Multimodal Store (rag_store.py)

Embedding text with task prefixes

Embedding files (PDFs, images, audio, video)

Search: cosine similarity per chunk, deduplicated per source

PCA projection in pure Python

The retrieval payload

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

4. The FastAPI Server (server.py)

5. The Frontend (very brief)

Running the App

Working Application Demo

Conclusion

LLM with 12M Context Window

AI Tutorial

Latest Developments

Quick Bites

Tools of the Trade

Multi-Agent Kanban board in Hermes Agent

AI Tutorial

Latest Developments

Quick Bites

Tools of the Trade

Build a Voice-First Insurance Claim Live Agent Team

What We’re Building

How It Works

Prerequisites

Code Walkthrough

Setting Up the Environment

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

Creating the App

schemas.py — Data Contracts

policies.py — Deterministic Insurance Rules

agent.py — The ADK Graph and the Workflow Bridge

live_demo/server.py — FastAPI Transport

__init__.py — Optional Surface for adk web

examples.py — Demo Prompts

Running the App

Working Application Demo

Conclusion

Open-source Claude Design

AI Tutorial

Latest Developments

Quick Bites

Tools of the Trade

AISLOPOPEDIA: The Complete Encyclopedia of AI-Generated Slop

SECTION 1: THE OPENERS

SECTION 2: THE BODY PATTERNS

SECTION 3: THE TRANSITIONS

SECTION 4: THE CLOSERS

SECTION 5: COMMENT SECTION CLASSICS

SECTION 6: THE EMOJI PATTERNS

SECTION 8: THE WORD CRIMES

SECTION 9: THE SENTENCE TEMPLATES

SECTION 10: THE SEVERITY SCALE

THE AI CONFESSION

Anatomy of Agent SKILLS

1. A skill is a folder

2. The first two lines are the search index

3. Progressive disclosure is the whole trick

4. Agent routes the query

5. Composition without context bloat

With Agent skills vs without

Slack for AI Employees

AI Tutorial

Latest Developments

1. The Shared Store (`app_state.py`)

2. The Multimodal Store (`rag_store.py`)

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

4. The FastAPI Server (`server.py`)

`schemas.py` — Data Contracts

`policies.py` — Deterministic Insurance Rules

`agent.py` — The ADK Graph and the Workflow Bridge

`live_demo/server.py` — FastAPI Transport

`init.py` — Optional Surface for `adk web`

`examples.py` — Demo Prompts