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.
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).
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).
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
Needle 3 is Cactus Compute's third-generation on-device foundation model — a single 8-29MB binary that handles tool calling, structured extraction, and text embeddings entirely offline, with no cloud and no network. Its defining trick is the 'intelligence ladder': one set of weights where every depth from 2 to 20 layers is a complete, deployable model, so a developer picks a 2-layer version for a smartwatch or the full 20-layer for a flagship phone — all from one training run. This deep dive covers the architecture (Monarch Hadamard MLP, grouped-query attention, an engram n-gram memory that lets the 121M model do the arithmetic of a 50M one), the benchmark claims and their fine print — 'passes DeepSeek V4 Flash' means fine-tuned on DroidCall, not a general win — the Pebble smartwatch partnership, and the open-core business model. The honest verdict: a serious specialist for offline, act-on-voice use cases, not a general-purpose chat model.
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.
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.
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.
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.
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.
Anthropic's Claude 5 models (Opus 5, Fable 5) invert the old prompting rules: being overly specific, spelling out steps, and telling the model to double-check its own work now degrade output. Simon Scrapes breaks down 7 new rules from Anthropic's own guidance. What to ADD: (1) replace step lists with a broader goal + success metric; (2) give the reason not only the request — intent lets the model make the 50 unstated decisions; (3) define 'done' explicitly because Claude 5 over-works (expands scope, adds unasked dashboards). What to REMOVE: (4) 'critical/always/never/must' + CAPS (over-triggers); (5) 'walk me through your reasoning' (Opus 5 already thinks; on Fable 5 it can trigger refusal) and 'double-check' (buys a second pass on done work); (6) state the boundaries — Claude 5 takes unrequested actions, so add 'report findings and stop'; (7) fix voice in one place — 'remove all mannered prose.' GPT-Astra agrees on goal+intent and over-checking, but has no action bias and ships a banned-words blocklist. Old skills need rewriting.
ECC ('Everything Claude Code') started in January as one developer's Claude Code config folder — 9 agents, 9 slash commands, 8 rule files, 7 skills from 10 months of daily use. It now has 255,000 stars, 38,000 forks, is MIT-licensed, and is the 16th most-starred repo on all of GitHub — above the Linux kernel — grown to 68 agents, 286 skills, 94 commands. The thesis: 'Optimize the context window. Persist everything else.' Core loop: plan (approve before code) → TDD gate (failing test first) → fresh-context review → distill sessions into summaries + 'instincts' (confidence-scored patterns) → cluster wins into new skills. It also ships AgentShield (scans your own setup as an attack surface with attacker/defender/auditor Opus agents), 24 hooks across 7 lifecycle events, and a June cut of default MCP connectors 6 → 1 (a skill wrapping a CLI is cheaper context). Caveats: 53/68 agents get bash, and the 'soul' identity file's numbers went stale months ago.
Google dropped TimesFM-3, a time-series foundation model that forecasts sales, inventory and revenue without ever training on your data. Surya (20 years in enterprise forecasting) builds a demand-planning app around it and tries to make it fail. TimesFM-3 reads your whole business at once — sales, weather, promotions, foot traffic — the multivariate unlock its predecessors lacked. It beat classical models handily on one synthetic test (MAPE 4.73 vs 6.72 Holt-Winters and 8.89 classical ML), with 330M parameters and 203ms latency. Under the hood: continuous patching (reads months as patches, not day-by-day) plus alternating horizontal (past-only) and vertical (cross-signal) attention. The verdict: it kills the baseline grind for teams without a forecasting function, but large retailers still train custom models. Weights ship under a non-commercial license; commercial use routes through Google's BigQuery platform.
Claude Opus 5 and Fable 5 are trained for end-to-end task execution, which inverts old prompting wisdom. Seven rules from Anthropic's guides and keynotes: (1) give the whole job (job + why + guardrails + done), not step-by-step; (2) use the 'interview me' skill to surface unknowns before complex tasks; (3) prompt the why, not just the what; (4) define what done looks like + output style (long-running models over-produce); (5) swap hard rules for reasoned instructions; (6) avoid double-checking prompts (they self-verify) and drop 'think step-by-step'/CAPS; (7) fix Claude's voice once in global instructions. Golden rule: 'Think of Claude as a brilliant but new employee — show your prompt to a colleague; if they'd be confused, Claude will be too.'