AI Agents

A three-agent workflow aims to find exposed personal data, identify removal procedures, and draft GDPR requests. The document sets out each agent’s role and instructions, then explains how to have them collaborate in a Cue group chat.

The process keeps human approval before emails are sent and says never to share passwords. It also distinguishes sites that catalogue data breaches from the organizations responsible for them, helping avoid contacting the wrong party.

This skill turns a coding agent into a security auditor by orchestrating a six-phase repository audit, from reconnaissance to report generation. Findings are structured as machine-readable data and independently verified.

A separate agent tries to disprove each candidate; results distinguish confirmed findings, leads needing validation, and rejected candidates. Running target code requires an OS-enforced sandbox with external networking disabled and resource limits in place.

Agent loops combine action, observation, and evaluation to refine an answer or retry an operation until it meets a criterion. Jesse Liberty demonstrates the pattern in C# with Microsoft Agent Framework: a loop agent, an evaluator, and an iteration limit.

The example contrasts a deterministic marker such as DONE with a model-based judge, then outlines safeguards to add: timeouts, idempotent calls, logging, and cost tracking. Each iteration adds latency and token usage.

Elephant-Goldfish Model, Google’s open-source plugin, provides skills to explore an idea, draft a specification, and challenge it before implementation. An “Elephant” agent keeps the project context; “Goldfish” reviewers inspect the document without the conversation history to surface unstated assumptions and risks.

The repository also covers resolving review findings and comparing documentation with code. Reviews require fresh subagent contexts; if the environment cannot create them, EGM stops that step.

Modern Web Guidance gives coding agents expert guidance on browser APIs, CSS, performance, and accessibility, steering them toward native solutions instead of legacy patterns. The repository brings together 232 features and 186 use cases as skills installable in multiple agents.

Its CLI searches locally for a guide and adds it to the agent’s context. The guidance incorporates Baseline compatibility data, targeted fallbacks, and automated evaluation; the project is marked as a preview release.

In Microsoft Agent Framework, ChatClient middleware intercepts messages exchanged with the LLM, while agent middleware operates on the agent’s overall run, including session, identity, or token-budget management. This distinction helps place logging or modification at the right level.

The C# example adds function-invocation middleware to log calls to the Researcher agent’s Tavily tool, without changing the other agents. The trace shows the function name and its arguments.

TanStack DB reaches 1.0 RC1 after extensive stabilization work. Kyle Mathews explains how test oracles—independent models that calculate expected behavior—and property-based testing uncovered bugs in collection updates and the change messages sent to subscribers.

These executable references also give coding agents precise rules to preserve when changing the implementation. The trade-off is clear: writing and refining models takes work, but their simplicity makes complex algorithms easier to verify. The RC also supports incremental adoption, from existing REST APIs to local persistence, offline mutations, and real-time sync.

TanStack AI 1.0 stabilizes its core APIs for combining chat, tools, media, and integrations across multiple providers and UI frameworks. Tree-shakable adapters and end-to-end tests using deterministic fixtures check the flows without live model calls.

The agent harness adds durable sessions, interrupts, and background work, but remains 0.x and may change in minor releases. Upgrading requires moving the stable packages together and supplying a threadId explicitly; passing the type check does not migrate persisted conversations or files.

The W3C has launched a second pilot in its open-source program: a polyfill for WebMCP, an incubating JavaScript API that lets applications expose functions as tools callable by agents and assistive technologies. The polyfill is intended to support experimentation and interoperability as the specification evolves.

Plans include publishing an npm package, tracking Web Platform Tests coverage, and advancing lifecycle events and declarative support. If WebMCP moves onto the standards track and interoperable native implementations emerge, the polyfill would be phased out gradually.

oh-my-hermes adds an orchestration layer to Hermes Agent: it maps work categories to models and reasoning effort, loads skills on demand, and can turn a goal into a graph of parallel tasks. Each task keeps a separate write scope, while a distinct node verifies the outcome.

A notable architectural choice is separating preparation from execution evidence: a plan is not treated as completed work, and an agent’s claim that it finished does not validate the result. The project also offers review-gated memory and a dedicated TUI, without replacing or patching Hermes Agent.

Archify is an open-source Agent Skill that helps an AI agent turn a description, question, or repository evidence into an interactive diagram or a concise page with a clear conclusion and sources. It supports ten diagram types, from architecture maps to timelines, and outputs a self-contained HTML file with no runtime dependencies.

Maps can be explored and refined in plain language, without learning a diagram editor. For one-page answers, sources can be pinned to a specific commit; the result can also be exported as a long image or PDF. The skill works with Claude Code, Codex, Cursor, OpenCode, and GitHub Copilot.

When an agent changes a UI, checking a single account cannot cover every role, plan, or feature flag. Matt Rothenberg shows how values scattered across hooks, providers, and layouts can hide overlooked states — such as a Delete button shown to a view-only user.

Making display state an explicit component input lets teams render relevant combinations directly, test them, or compare them in a visual grid. Storybook and Playwright complement this approach, but they do not choose which scenarios to cover; that decision still matters.

Chums connects an Apple Watch and iPhone to Claude Code or Codex agents running on a Mac. Its interface makes agent activity visible, shows tool calls, and lets users respond to permission requests or dictate instructions.

The Node.js hub stays on the Mac, but the watch API is exposed through Tailscale Funnel and protected by a token. The project is open source and requires no Chums account, though setup involves building the apps with Xcode and configuring several dependencies—a trade-off between local control and a more demanding installation.

Claude SEO turns Claude Code into an SEO auditing tool: specialist agents assess indexing, performance, content, structured data and visibility in AI search, then produce a prioritized action plan. Reports stay on the machine, but analyzed pages are sent to Claude, as with other Claude Code workflows.

The repository also emphasizes tooling reliability, with automated checks, support for Python 3.11 through 3.14, and safeguards against untrusted web content. Live-data extensions are optional; without Google API keys, Core Web Vitals results are lab estimates.

Vercel Shop pairs a Next.js storefront with Shopify, which remains responsible for the catalog, payments, and checkout. Cache Components serve product data quickly, then stream personalized content; meanwhile, the cart updates before the server responds through an optimistic UI.

The template adds agent-facing options: an opt-in shopping assistant, skills for extending the store, and Markdown served through the Accept header. It offers a concrete starting point for these flows while keeping Shopify as the commerce engine.

PostHog shares practical guidance for writing skills that help agents without locking them into a brittle workflow. The core idea is to load context progressively, define the goal and constraints, then let the agent choose steps that fit the repository and runtime environment.

The article also addresses maintenance: separate durable structure from fast-changing details, point to a single source of truth, and regenerate skills instead of patching them indefinitely. Skills carry context and upkeep costs, so they make most sense for recurring tasks where agents lack essential context or perform poorly by default.