Deep dives into working agents.

Technical walkthroughs with substance: architectures, prompting patterns, evals, and production lessons unpacked until complex agent systems become reusable design material.

Page 1 of 3 · showing 1–24 of 72

Show the outdated contentHistory

Sparks of Weight-Space Programming: LLMs That Read and Write Neural Weights

An MIT CSAIL post shows a frontier model reading raw weights and saying what a network does — four games from 17,253 numbers, no options given — then fixing a car policy in one shot by editing 3.5% of its weights, writing game networks from scratch that beat 100M steps of PPO, and lifting Qwen3.5-0.8B maths from 7.9% to 48.1% by removing a repetition direction from 0.016% of its weights. Includes the experiment that keeps it honest: on Gemma, which rarely loops, the same editing changed nothing — you can remove an obstacle that hides an ability, not add one that is missing. All figures checked against the paper, not the video.

deep-dives

Matthew Berman

Published2026-11-04

Five Documents, One Argument: What Anthropic Actually Published About Claude 5

Between July and October 2026 Anthropic published five pieces of guidance on working with Claude 5 models: context engineering, the Opus 5.5 prompting guide, skill authoring, two essays on effort, and folding subagents into a single loop. Read together they are one thesis - as the model gets more capable, the harness should shrink.

deep-dives

The Agent Daily

Published2026-10-29

Training Agents at the Frontier of Industry: A Hugging Face Workshop

A 2-hour Hugging Face workshop on training agents with RL post-training, environments, and benchmarks. Govind Kamtamneni (Microsoft Foundry/GitHub) on the hill-climbing loop with verifiable rewards, SFT+RL+DPO+distillation, and decision models; Victor Barres (Mercor, ex-Sierra tau-Bench) on reward vs measurement and reliability bounding validity; Tao Lin (Radix Ark) on the Miles RL framework (fully async RL, fresh sandbox per episode, GLM-5.2 on Terminal Bench 2); Xiang Li (BenchFlow) on OpenEnv Arena vetting 90k environments down to 800. Q&A covers why few train their own agents (MLOps gap), team composition, model fatigue vs post-training cost, continual learning, superhuman evals (Program Bench), and agent-vs-human products.

deep-dives

Hugging Face

Published2026-10-27

The Exponential Time Hypothesis Is False: Two AI Labs Claimed the Same Refutation on the Same Day

On 16 October 2026 an internal OpenAI model and an internal Anthropic model both found a deterministic subexponential algorithm for 3-SAT, which would refute the Exponential Time Hypothesis - a 1999 assumption more than 800 papers are built on. What the two papers actually prove, what Lean does and does not check, why the result changes nothing in practice below 10^10,000 variables, and why the hypothesis's own authors say their involvement is not certification.

deep-dives

Refreshing AI Latest

Published2026-10-27

Let Your AI Agent Do Its Own Harness Engineering

Cole Medin shows how the harness-engineering ideas behind coding agents translate to production agents: a markdown-based harness (rules, sub-agents, MCP, skills, hooks) plus two improvement loops — memory (escalate uncertainty, learn lessons) and retroactive fixes (trace-driven proposed edits to instructions.md, human-approved). A help-desk demo goes from 4/14 to 13/14 correct on real questions.

deep-dives

Cole Medin

Published2026-10-21

Memory-Aware Agent Harnesses for Anti-Money Laundering

Nacho Martinez (Oracle) walks through building a memory-aware agent harness for AML at AI Engineer NYC: short/long-term memory (episodic/procedural/semantic), context engineering vs the KV cache, files-vs-databases, the agent loop, vectorized toolbox/skillbox + skill distillation, instruction hierarchy, semantic cache, and a 24/7 Grok-on-OCI agent that flags (not blocks) transactions for human review.

deep-dives

AI Engineer

Published2026-10-18

Jev Can Now See: Image Analysis and the Box Type

The AI Automators tests Jev 1.14 (TypeSafe AI, released Oct 14, 2026), which adds experimental image input and a new 'box' question type that returns object coordinates — turning the fast decision model multimodal. Demos: 200 support tickets classified in ~4s for 2¢, a shelf-of-liquids playground (hazard pictogram, pH scale), and a 1,000-case controlled test with 93.4% accuracy, zero mistakes above a 65% confidence gate, and a calibration deep-dive (under-confident on auto-decisions, over-confident on review cases). Covers the box-type 'no not-found' gotcha, image-in-state/criteria patterns, and competitors (Cloudflare Clef, Win12B, Decider4B).

deep-dives

The AI Automators

Published2026-10-16

Why Every AI Company Is Suddenly Obsessed With Blender

Arts Supremo lays out four reasons AI 3D companies are converging on Blender: it's fully open source (no Autodesk-style gatekeeper), its complete Python API (bpy) lets LLMs script the software like a human, its official 2026 MCP server gives AI agents native natural-language control, and its existing retopology/modifier/geometry-node toolset cleans up the 'triangle soup' that AI mesh generators produce. Then a rundown of the 2026 tool ecosystem (Meshy, Dream Textures, 3D Agent, Viper Mesh, Mesh Gen, and more) and the argument that Blender becomes the OS for AI-generated 3D. Verified: the open-source status, bpy, the official blender.org MCP server, and huggingface/meshgen (931 stars).

deep-dives

Arts Supremo

Published2026-10-15

TabFM: Google's 'GPT-3 Moment' for Databases & Spreadsheets

Prompt Engineering walks through TabFM, Google Research's foundation model for tabular data — positioned as the 'GPT-3 moment for tables.' Where tabular ML traditionally means cleaning, hand-engineering features, training gradient-boosted trees, and repeating per dataset, TabFM (400M params) does zero-shot prediction via in-context learning: you pass labeled rows plus the unlabeled rows you want scored, and it infers answers in a single forward pass — 'your dataset is literally the prompt.' It was trained entirely on synthetic tables generated from random causal DAGs, so it learns the meta-algorithm of learning-from-tables but has never seen column headers — a semantic gap that TabFM-Auto (arXiv 2609.37989) closes by pairing a frozen TabFM with an LLM agent that reads column names, writes transformations, and calibrates predictions. The host then demonstrates a real agentic loop (churn prediction on Postgres/Neon, TabFM on a DGX Spark): zero feature engineering beat a tuned tree model, and the leakage lesson — a 'retention' column populated only after cancellation fooled the agent half the time until he trained against a timestamp-restored branch. TabFM repo (2,738★), TabFM-Auto paper, and TabArena benchmark all verified. Neon is the sponsor; weights are non-commercial research-only.

deep-dives

Prompt Engineering

Published2026-10-11

OpenAI's Decisions API: GPT-6 Luna Makes Fast Decisions

OpenAI's official launch of the Decisions API (public beta, Oct 6 2026) — a specialized endpoint for making fast, finite decisions rather than generating prose. It runs on GPT-6 Luna, and you give it text or an image, define a question and the possible answers, and get a typed choice back in under 100ms — nearly 10x faster than a reasoning model while keeping image understanding, broad language support, and safety. OpenAI names classification, routing, and choosing an agent's next step as the target use cases. The launch video demos it across modalities: routing loose user input into sales leads in real time; steering a car in a driving game from video frames; pairing with GPT-Live-1 to drive an animated character's expressions; and steering Hugging Face's open-source Microduck robot ("Lavender") to look at objects via its camera — including ambiguous prompts like "what's more fun to play with?" OpenAI is explicit that sophisticated computer-use still wants Astra, so this is the fast/simple layer. It's the frontier lab entering the decision-model category that TypeSafe's Jev helped open. API, model, and robot are verified; the speed/latency figures are OpenAI's own.

deep-dives

OpenAI

Published2026-10-08

Jev: The Decision Model That Filters Your Second Brain

Cole Medin distills four production use cases for Jev — TypeSafe's 'System One' decision model, served through OpenRouter's Decisions endpoint — inside his AI second brain. Jev doesn't generate text; it takes a state plus a batch of multiple-choice questions and returns typed decisions in parallel with confidence scores, claimed at 20–200× faster and 40–1,000× cheaper than an LLM. His dashboard makes the economics concrete: 38,000 calls and 55.3M tokens in a week for $21. The four use cases: a prompt-injection guard that screens every incoming email (now with per-question confidence and a quarantine threshold), a 'worth replying?' triage that labels each email reply/skip/injection before an LLM (GLM 5.3 Flash or Haiku) drafts the reply, news-filtering across RSS and YouTube where Jev does the cheap bulk cut, and duplicate detection against a personal knowledge base where it beat semantic-similarity matching. The honest limitation worth stealing: Jev can't fully replace the LLM on high-context decisions (like 'is this a fit for my audience'), so the pattern is Jev as the fast-cheap first pass and a small LLM as the high-context last mile. Jev is verified against OpenRouter's docs; the speed/cost multiples are flagged as vendor claims.

deep-dives

Cole Medin

Published2026-10-08

AI Skills with Matt Pocock: Grill Me, Wayfinder, and Software Fundamentals

Matt Pocock is the creator of grill me, the widely-used skill that has the agent interview you relentlessly before you write a line of code, and his skills repo is now one of the most-starred on GitHub. In this conversation he explains the philosophy behind it all: knowledge has become cheap while wisdom has not, so the job shifts from tactical syntax to strategic programming. His workflow splits planning and execution into a day shift and a night shift, turns a grilling session into a spec and then tickets, and uses a wayfinder skill with a map and fog-of-war metaphor to plan work of infinite length. His key insight is leading words, terms like tracer bullet, vertical slice, and ubiquitous language that sit in a model's priors from the classic software engineering books, so naming the right concept changes the agent's behavior. The through-line is that clean, well-structured code matters more than ever, because agents start fresh every session and treat your codebase as their environment.

deep-dives

The Pragmatic Engineer

Published2026-10-04

Everything You Know About Skills Is Outdated

Simon Scrapes walks through Anthropic's updated best-practices guide for building Claude skills, and the headline is a quiet breaking change: Claude runs a head-like command that reads only the first 100 lines of a reference file, so any rules past line 100 effectively do not exist. The fix is seven rules that apply to every skill you have already built. Put a contents list at the top of any reference file over 100 lines, match the level of detail to the task's fragility with three degrees of freedom, test each skill on every model you plan to run it with, keep all reference files one level deep from SKILL.md, give ordered multi-step processes a checklist it can tick off, add a self-correction loop that runs a check and repeats until it passes, and spell out dependencies instead of assuming they are installed. The through-line is that skill quality now comes from file layout and the checks a skill runs, not from how cleverly the instructions are written.

deep-dives

Simon Scrapes

Published2026-10-01

Anthropic's Guide to Mastering Opus 5.5

Brock Mesarich speedruns Anthropic's official prompting guide for Claude Opus 5.5 — the eight changes that matter most. The headline is that the default effort level quietly dropped from high to medium, so keeping an old high-effort configuration now buys longer turns and more output tokens for no measured gain. The other seven tips are equally practical: retire now-redundant 'think carefully' instructions, tell the model to check every source instead of trusting the first document, separate your request from pasted content, understand why a custom app can hide Claude's progress updates, treat a finished reply as possibly unfinished work, replace 'make it less generic' with concrete design choices, and help it read dense charts with crops and close-ups. The payoff is better answers and lower token costs.

deep-dives

Brock Mesarich

Published2026-10-01

SimpleBrain: A Second Brain Without Obsidian — Folders, Prompts, and a Daily Automation

Chris Ashby's 'SimpleBrain' is a second brain that skips Obsidian's complexity for five folders and three files, built on Andrej Karpathy's self-documenting knowledge-base idea. The loop is two steps: dump anything readable (PDFs, CSVs, JSON, URLs, voice notes) into a raw folder, and let an AI agent run a single translate.md prompt that turns it into a curated wiki and moves the processed files to archive. The instruction files (CLAUDE.md, AGENTS.md) encode the safety rules — never delete, merge before overwriting, commit to Git, and note uncertainty instead of guessing. A scheduled task runs the translation daily on a cheap model (Sonnet 4.6), and extensions layer on top: voice-memo transcription, YouTube/podcast transcripts via yt-dlp, and a weekly synthesis of themes and decisions.

deep-dives

Build Great Products (Chris Ashby)

Published2026-09-14

Claude + Jev for Computer Use: Build with Opus, Automate with Jev

Kev Builds Apps shows how pairing a frontier model (Claude Opus 5.5) with a System 1 decision model (Jev) makes computer-use agents faster than a human and nearly free. The pattern: Claude Opus learns a workflow (scraping competitors, sending LinkedIn requests) and writes it into a SKILL.md, then that skill is handed to Jev as one of its choice options — so the routine runs on Jev's under-500ms, fraction-of-a-cent decisions, with Claude held back as an expensive fallback for when the UI changes. The stack is all free and open source: Playwright MCP for static steps, browser-use for dynamic exploration, Supabase for data, and a Mac mini with launchd to trigger it. Demos include Jev beating chess.com players (with Stockfish feeding it probabilities) and a Facebook Marketplace car-flipper that Claude teaches and Jev then runs at ~95% of the steps offloaded.

deep-dives

Kev Builds Apps

Published2026-09-14

Anthropic's Opus 5.5 Prompting Guide: 11 Changes to Make

Anthropic published its own prompting guide for Opus 5.5, and Mansel Scheffel broke it into 11 practical changes. The through-line is that 'thinking' now costs expensive output tokens, so you calibrate it like a budget: Opus 5.5 on medium already matches Opus 5 on high, old 'think step by step' prompts are redundant (adaptive thinking is on by default), and every recheck burns tokens you don't need to spend. The guide covers task lists for unattended runs, how to rephrase safeguard-refused questions (in a fresh session), progress updates, explore-before-acting, time signals for agent teams, marking pasted text against prompt injection, cropping images for visual accuracy, and steering design away from AI slop.

deep-dives

Mansel Scheffel

Published2026-09-14

MiMo-V2.6: Xiaomi's Trillion-Parameter Open Model, Trained in Public

Xiaomi's MiMo team — led by ex-DeepSeek researcher Luo Fuli — did something almost unheard of: they streamed the reinforcement-learning training of their new models on a public dashboard, GPU failures and cost counter included. Out came MiMo-V2.6, an MIT-licensed open-weights family: the 1.02-trillion-parameter Pro (42B active, sparse MoE), the leaner Flash, a speed-tuned UltraSpeed, and a Distill-Qwen-9B — all natively omnimodal with a 1M-token context. The benchmarks put it shoulder-to-shoulder with Claude Opus 5 and GPT-5.6 Sol on coding and agent tasks, and the pricing stayed identical to the previous generation. The honest caveats: every benchmark is Xiaomi's own (none independently verified), the training code shipped after the weights, and a couple of numbers don't quite add up.

deep-dives

Panda Making Money

Published2026-09-14

Laya: The Open-Source, Faster Jev — System 1 Models Go Local

Days after TypeSafe's Jev went live, Convai Innovations shipped Laya — an open-source System 1 model that returns typed decisions instead of text, runs on your own hardware, and benchmarks faster (7–14ms on Apple Silicon via the MLX runtime). This video breaks down what System 1 models are (Kahneman's fast, instinctive thinking, applied to classification), runs Laya locally on a Snake-playing demo at ~30 decisions/second, and swaps Jev out of the browser-use Google Flights demo with Claude Code — nearly in one shot. The honest verdict: Laya is slightly less accurate than Jev today, but it's open, free, local, and cloned a three-year stealth project in under a week.

deep-dives

CoderOne

Published2026-09-14

Anthropic's Claude Engineering Masterclass: Prompting, Agent Architecture, Routines, and Memory (Full 4-Hour Session)

A complete recording of Anthropic's Code with Claude London workshops, with eight applied-AI engineers covering the full production playbook. Margot Vanlar's prompting session debugs a telco support bot through three failure modes — the model withholding information it has, instructions not adding capability (give it a tool), and one-sided trade-offs — then builds a scheduling agent and lands on a generate-evaluate-repair loop. Will decomposes an inventory agent from a 400-line prompt, 12 tools, and 3 sub-agents down to a 15-line prompt, 3 primitives, and skills, climbing evals from 62% to 92%. Arno pushes HTML-over-markdown, 'let Claude interview you,' and verification built into the artifact. Ivan runs Claude on Google Cloud across five personas. Maya's routines turn Claude from tool into teammate, Kevin's memory stores plus dreaming give agents continuity across sessions, and the closing talk argues the bottleneck has moved from coding to verification and review. 23 sections, 46 timestamps, and the reusable frameworks behind each.

deep-dives

Anthropic

Published2026-09-14

Meet Jev: TypeSafe's Classifier Model Built to Make Decisions — 200ms, Output Tokens Free

Jev, from TypeSafe AI, is a new class of model: not a chatbot, but a classifier built to make structured decisions inside software. Feed it JSON rules and unstructured input, and it returns typed, probabilistic decisions — no string generation, so nothing to hallucinate, parse, or validate. vogel puts it to work on 1,500 of his own emails (category, priority, spam, reply), sees ~200ms per email at ~38/sec, then scales to 1,000 emails and finds the whole run cost about 5 cents. TypeSafe's own numbers: 40-200x faster than frontier LLMs on structured-decision tasks, input at $0.042 per million tokens, and output tokens literally free. Note: the video says 'the co-founder of ChatGPT' — the founder is actually Diogo Almeida, who worked at OpenAI on the research behind ChatGPT.

deep-dives

vogel

Published2026-09-14

TrueForge: The Open-Source Managed Agent — Why the Harness Matters More Than the Model

TrueForge, from TrueFoundry, is an MIT-licensed TypeScript managed agent you run yourself — clone it, spin it up with one npx command, and you get the full runtime layer (streaming, session persistence, sandboxes, approvals, a UI) that hosted platforms like Claude managed agents charge a premium for, but on any model, with zero vendor lock-in. Sam Witteveen walks through the three kinds of agent harnesses, then the benchmark that made the case: the same model on the same enterprise tasks through TrueForge's harness used 3.8M tokens per run versus 10M on Claude managed agents — a 30% cost cut with identical accuracy, and 75% cheaper still on an open model. The headline is cost, but the bigger deal is lock-in and data retention, and the roadmap (local sandboxes, gateway integration) closes the gap with the hosted offerings.

deep-dives

Sam Witteveen

Published2026-09-14

Google's A2A Protocol Just Got a CLI

The A2A CLI (a2a) — the official command-line client for Google's Agent-to-Agent protocol — gives terminals, scripts, and coding assistants a readymade way to discover, message, and manage A2A agents. This deep dive covers what A2A is, what the CLI adds, the three-verb usage, and a live demo connecting two ADK agents (marketing + supply chain) through Antigravity — including the chained agent-to-agent call.

deep-dives

AI with Surya

Published2026-09-11

Google WikiSkill Teaches Itself Your Company's Rules (No Fine-Tuning!)

WikiSkill — a Google Research framework — compiles an agent's own experience into a persistent wiki of company rules. A worker executes, a note-taker records mistakes, a playbook writer compiles the lessons, and a strict manager keeps only what improves unseen work — no retraining, no fine-tuning. This deep dive covers the paper, the four-role architecture, and a live spreadsheet-cleaning demo with and without the learned skill.

deep-dives

AI with Surya

Published2026-09-11