Agents-OSS — AI Agent OSS, curated

Addy Osmani's Agent Skills — Twenty-five skills that walk a coding agent through spec, plan, build, test, review and ship in that order

Sat, 29 Aug 2026 00:00:00 GMT

Left alone, a coding agent starts writing code the moment you finish the sentence. This is a set of skills that puts the usual engineering order back: nine commands cover the stages from working out what to build to shipping it, and the skills behind them attach on their own when the work calls for one — designing an interface pulls in the interface skill, touching the front end pulls in that one. Notably the automatic mode does not remove the checks, only the person stepping between tasks: each task is still test-driven, committed on its own, and paused on failure. It is Markdown, so it installs into around seventy agents through the open skills command.

AG2 — The community's continuation of AutoGen, now rebuilt around a protocol with the original classes moved aside

Sat, 29 Aug 2026 00:00:00 GMT

When AutoGen went into maintenance mode it left two ways forward, and this is the community one: the same volunteers, the same conversation-driven idea of several agents talking a task through, carried on outside Microsoft. Anyone arriving from AutoGen needs to know what version 1.0 did, though. The classic classes people actually wrote code against — ConversableAgent, GroupChat, the `autogen` import name — have moved to a separate repository maintained alongside this one, and `pip install ag2` now gives you a newer protocol-driven framework instead. Existing code keeps working; it just no longer lives here.

Blender MCP — Puts Blender behind an MCP connection so an assistant can build and change a 3D scene by conversation

Sat, 29 Aug 2026 00:00:00 GMT

Blender is powerful and its learning curve is the reason most people never get past a cube. This bridges it to any MCP-capable assistant: an add-on inside Blender opens a connection, and from the other side the model can create and move objects, apply materials, inspect the scene and run Python against Blender's own API. That last part is the important detail and the main risk — the assistant is not limited to a fixed set of operations, so it can do things you did not anticipate in a file you care about. Installation is genuinely three steps, but they span two programs: a package runner, an MCP client entry, and an add-on enabled inside Blender itself.

Diagram Design — Thirty-nine diagram types an agent can draw as self-contained HTML and SVG, without Mermaid's default look

Sat, 29 Aug 2026 00:00:00 GMT

Asking an agent for a diagram usually returns rounded boxes and arrows that look nothing like the document they are going into, so the diagram gets dropped. This skill gives the agent a vocabulary instead: thirty-nine named layouts — architecture, sequence, swimlane, quadrant, Sankey, fishbone, Wardley map, story map and more — each shipped in light, dark and full-editorial variants as one HTML file with inline SVG. No build step, no JavaScript, no external images: open the file in a browser or drop it into a page. It can also read your site to pick up the brand, and redraw an existing draw.io or Mermaid source at a chosen size and level of detail.

Distilly — Builds a source-grounded profile of how a particular person works and judges, and packages it as a skill

Sat, 29 Aug 2026 00:00:00 GMT

When the person who knew why the system is like that leaves, the documentation they wrote turns out to be the small half of what they knew. Distilly is an attempt at the other half: you give it their messages, documents, interviews or public writing, and it produces a profile of the observable pattern — how they decided things, what they insisted on, how they said it — packaged as a skill an agent can load. The maintainers are careful about what it claims, and so should you be: the output is grounded in the material you supplied and does not claim to be the person. The obvious caution is consent, since the material it works from is usually someone else's.

Giskard — Attacks your own agent with hostile inputs and reports the ones it answered when it should have refused

Sat, 29 Aug 2026 00:00:00 GMT

Evaluation tells you how well an agent does on the questions you thought of. That is the wrong shape for safety, where what matters is the question you did not think of. Giskard inverts it: the scan generates hostile inputs itself and reports the ones your agent answered when it should have refused, so the test set is produced by the tool rather than by your imagination. Alongside it sits a scan for the ways a retrieval system quietly goes wrong, and a way of writing behavioural expectations as ordinary tests that pass or fail under pytest, so a check that mattered once becomes a check that runs on every change. The maintainers are explicit that a clean scan is not a safety or compliance guarantee.

Helicone — Logs every model call by sitting in the request path, so nothing in your code has to be instrumented

Sat, 29 Aug 2026 00:00:00 GMT

Most tracing tools ask you to wrap your calls, which is fine until the code you need to see is inside a library, a background job or a service somebody else owns. Helicone takes the other route: point the base URL at it and every request is logged on the way through, with no SDK in the path. Because it is already in that position it does gateway work too — one key for many providers, automatic fallback when one is down, caching for repeated prompts. The trade is the position itself: a proxy is now between your application and the model, which is a component to run and a hop to account for. Agent runs group into sessions so a multi-step trace reads as one thing rather than thirty unrelated calls.

Hindsight — Memory that consolidates repeated facts into beliefs with evidence, rather than storing every mention separately

Sat, 29 Aug 2026 00:00:00 GMT

Storing an agent's conversations and searching them back is the easy half. The hard half is that the same thing gets said ten times in slightly different words, and a later correction has to win over an earlier statement. Hindsight is built around that: related facts are merged into a single belief that carries its evidence and updates as new evidence arrives, so a change of mind reads as an update rather than as two contradictory records. Retrieval runs four strategies at once — meaning, keywords, relationships and time — because a question about what changed last month is not answered by similarity. It is a server you run rather than a library you import, with an MCP interface and clients in several languages.

HolmesGPT — An incident-investigation agent that queries your existing monitoring instead of asking you to paste logs into a chat

Sat, 29 Aug 2026 00:00:00 GMT

The slow part of an incident is not the fix, it is the twenty minutes of pulling up dashboards, matching a spike to a deploy and finding the pod that actually failed. HolmesGPT does that part: it connects to what you already run — Prometheus, Grafana, Datadog, Kubernetes, any REST API — and works through the question in a loop, fetching what it needs and following what it finds, then writes the conclusion back to the alert it came from. Notably it is built for the scale that breaks naive tools: results are filtered on the server, large outputs are streamed to disk and each tool has a memory limit, so querying a big observability dataset does not fill a context window or kill the process. It is a CNCF sandbox project.

Humanizer — Rewrites text that reads as machine-written, against a public checklist of the tells, without changing what it says

Sat, 29 Aug 2026 00:00:00 GMT

The problem with asking a model to make its own writing sound less like a model is that it has no list of what gives it away. Humanizer supplies one: thirty-five patterns from the checklist Wikipedia's editors maintain for spotting AI-written articles. It drafts a rewrite without treating the original structure as fixed, then checks that draft against the same patterns and against the original claims before going again, and it shows the intermediate pass and its own critique rather than only the result. It does not invent: names, numbers, dates and citations must come from the source. Pointed at a file it changes prose only, leaving code, data and link targets alone.

ContextForge — One endpoint in front of every MCP server, A2A agent and REST API you have, with a registry and access control behind it

Sat, 29 Aug 2026 00:00:00 GMT

The MCP problem an organisation hits is not writing a server, it is that after a year there are forty of them, nobody has a list, and each client is configured by hand. ContextForge is the registry and proxy for that situation: servers are registered once and discovered from one place, existing REST and gRPC services can be exposed as MCP without being rewritten, A2A agents are routed the same way, and authentication, rate limits and tracing are applied centrally instead of per server. It is itself a compliant MCP server, so clients see one endpoint. The weight is the obvious cost — this is infrastructure with a database, a cache and a Kubernetes story, which is a lot to run if you have three servers rather than forty.

Planning with Files — Keeps the plan in three files on disk and re-injects them every turn, so it survives a cleared context

Sat, 29 Aug 2026 00:00:00 GMT

A long task fails in a particular way: the agent had a plan, the context was cleared or compacted, and what comes back is an agent confidently finishing a different job. This skill moves the plan out of the conversation and onto disk — one file for the plan, one for what has been found, one for what is done — and puts them back in front of the agent on every turn. Because the plan is a file, it outlives a clear, a crash and a compaction, and you can read it yourself while the run is going. An optional gate stops the agent declaring completion until the plan says so. The maintainers publish blind A/B results, which is more than most skills offer.

Ponytail — A skill whose whole job is talking the agent out of writing code it does not need

Sat, 29 Aug 2026 00:00:00 GMT

Ask an agent for a date picker and you can get a dependency, a wrapper component, a stylesheet and a conversation about time zones, when the browser has had `` for years. Ponytail is a single skill aimed at that habit: it pushes the agent towards the smallest thing that works, and towards not writing anything when the platform already provides it. What makes it worth a look rather than a joke is that the maintainers measured it — twelve real tasks on a real repository, with and without the skill — and published the method alongside the numbers, including a note that an earlier, more flattering figure was the per-task ceiling rather than the average.

Scientific Agent Skills — Turns a general coding agent into a research assistant that knows the databases and libraries of a field

Sat, 29 Aug 2026 00:00:00 GMT

An agent can already call any Python library, but it will use a specialist bioinformatics package the way someone reads the docs for the first time — plausibly, and wrong in the ways that matter. This supplies the missing half: over 160 skills that carry the curated usage and worked examples for specific scientific tools, plus access to a hundred or so public databases, across genomics, chemistry, drug discovery, proteomics, clinical research, imaging, physics and geospatial work. It installs as one plugin or skill by skill. Read the scope notes before relying on it, though — the clinical and healthcare skills are written for research and retrospective validation, and say plainly that they are not for patient-specific decisions.

Semble — Answers a coding agent's "where is authentication handled?" with the relevant snippets, not with whole files

Sat, 29 Aug 2026 00:00:00 GMT

The expensive habit of a coding agent is grep, then read the eight files it matched, then read three more because the answer was not there. Semble replaces that with one question in plain language and a handful of relevant snippets back — the maintainers put the saving at roughly 99% of the tokens against grep plus reading. It runs entirely on the machine, on CPU, with no API key and no service to call, and indexing a full repository takes under a second, which is what makes it practical to point at whatever the agent happens to be working on. Installation detects the agents you have and offers three ways in: an MCP tool, a line in your agent instructions, or a dedicated search sub-agent.

Skill Seekers — Turns a documentation site, a repository or a PDF into a skill the agent can load, instead of re-reading it every time

Sat, 29 Aug 2026 00:00:00 GMT

An agent working against an unfamiliar library reads the same documentation site over and over, a page at a time, paying for it on every run. Skill Seekers converts that source once: point it at a documentation site, a repository, a PDF, a wiki or a video and it produces a structured knowledge asset, which it can then export as an agent skill or into a retrieval pipeline. Eighteen kinds of source go in and it can package for a couple of dozen destinations, so the same extraction serves a coding assistant and a search index. It also checks for conflicts, which is the failure mode when two versions of the same documentation end up loaded at once.

Windows Agent Arena — The Windows counterpart to OSWorld: real applications, real tasks, and a cloud runner so a full pass takes minutes

Sat, 29 Aug 2026 00:00:00 GMT

Almost every desktop-agent benchmark runs on Linux, and almost every desktop that matters commercially runs Windows. This is Microsoft's answer to that gap — a reproducible Windows environment with tasks across the applications people actually use, scored on whether the task was completed. Its useful trick is parallelism: runs can be spread across cloud machines so a few hundred tasks finish in minutes instead of over a day, which is what makes it usable during development rather than only at publication time. Read the last commit date before planning around it, though — this is a research artefact tied to a 2024 paper, and it has moved slowly since.

XcodeBuildMCP — Gives a coding agent the Xcode build, simulator and log commands it otherwise has to guess at

Sat, 29 Aug 2026 00:00:00 GMT

A coding agent working on an iOS project can write Swift all day and never find out whether it compiles, because the commands that would tell it are long, particular and easy to get subtly wrong. This exposes them properly: build a scheme, boot a simulator, install and launch the app, read the logs, run the tests. Because the agent gets a result it can act on, the loop closes — it fixes the error it just caused instead of handing you a diff to try. It ships as both an MCP server and a plain command-line tool, with optional skills that tell the agent how to use whichever one you installed. It is macOS-only and tracks a current Xcode.

Agent Governance Toolkit — Wrap a tool in a written policy so that every call is checked, logged, and refused when the rules say no

Thu, 27 Aug 2026 00:00:00 GMT

The permissions an agent inherits are the ones its credentials carry, which is almost never the set of things it should be allowed to do: a key that can read a table can usually drop it. This toolkit closes that gap at the point of the call. You write the rules as a YAML file — deny anything destructive, require a named group's approval before an email goes out — wrap the tool function, and every call is evaluated, written to an audit trail, and refused with an explanation when a rule blocks it. Alongside that sit an identity scheme for attributing an action to a specific agent and a sandboxing layer for tools you would rather not run in your own process. It is a public preview, and the package layout has already moved once.

Agent Lightning — Trains the model inside an agent you have already built, by sitting between it and the model instead of rewriting it

Thu, 27 Aug 2026 00:00:00 GMT

The usual objection to reinforcement learning for agents is that it means rebuilding the agent as a training environment, at which point you are no longer improving the thing you run. Agent Lightning avoids that by putting a proxy where the model endpoint used to be: the agent keeps its own tools, prompts, control flow and environment, and every interaction that passes through the proxy becomes training data. A trainer updates the policy, a controller runs the agent locally or as Kubernetes jobs. Microsoft reports taking a 9B model from 41.8% to 56.4% on SWE-bench Verified using 6,000 samples, and publishes that pipeline. This is GPU work with a training stack behind it, not a library you add to an application.

Agent S — A desktop agent that pairs a reasoning model with a separate model trained only to find the thing on screen

Thu, 27 Aug 2026 00:00:00 GMT

Agent S separates two jobs that a single model does badly at once: deciding what to do next, and working out where on the screen to click. A general model handles the planning; a smaller vision model, run separately, converts "the Save button" into coordinates. That split is why it scores as it does — Simular reports 72.60% on OSWorld with its best-of-several-attempts setting, against roughly 72% for humans. It is also why setup is more work than a pip install: you supply the grounding model as its own endpoint and tell the agent what resolution it reports coordinates in. By default it drives your actual desktop, one monitor, with no sandbox in between.

AgentBench — Measures a model as an agent by putting it in a shell, a database and a shopping site, not in a question-and-answer set

Thu, 27 Aug 2026 00:00:00 GMT

A model that answers well can still be poor at operating something, and a question-and-answer benchmark will not show that. AgentBench puts a model into environments that push back: a shell it has to work in, a database it has to query, a knowledge graph, a text world and a shopping site where the task only counts if the right item ends up ordered. Every task is scored on whether it was completed, not on whether the reasoning read well. The current release runs those environments as containers driven by function calling, which makes it reproducible on your own hardware — with the practical caveats the maintainers list, including one environment that needs about 16GB of memory and another that leaks until its worker is restarted.

AgentScope — A reasoning-and-acting agent shipped with the production parts: sandboxed tools, context control, a service layer

Thu, 27 Aug 2026 00:00:00 GMT

AgentScope starts where most frameworks start — an agent that reasons, calls a tool, looks at the result and goes round again — and then supplies the parts that usually have to be built afterwards. Tools run inside an isolated environment rather than in your process; context is compressed and offloaded as it grows instead of simply overflowing; a person can be asked to approve a step; and the finished agent can be served as a multi-tenant backend with its own interface. The price of that reach is that version 2.0 was a deliberate break from 1.0, so material written for the older releases does not carry over.

CopilotKit — The user-facing half of an agent: what the agent can see on the page, what it can change, and what it renders back

Thu, 27 Aug 2026 00:00:00 GMT

An agent that only produces text wastes the application it lives in. CopilotKit connects the two: a hook publishes part of your application state so the agent can read it, another registers a frontend function the agent may call, and a third lets the agent answer with a real React component rather than a paragraph — a form to confirm, a chart, a diff to approve. It talks to backends through AG-UI, the protocol the same team publishes, so the agent can be LangGraph, CrewAI, the Claude Agent SDK or several others without changing the frontend. What it does not do is be the agent: you still bring one, and the smooth path is React.

Cua — Four ways to give an agent a computer: a background driver, a sandbox for any OS, benchmarks, a macOS hypervisor

Thu, 27 Aug 2026 00:00:00 GMT

Computer use runs into the same wall every time — the agent needs a machine, and it cannot be the one you are working on. Cua is four answers to that, which is worth knowing before you install it, because you almost certainly want one of them rather than all four. The drivers let an agent click and type in native applications in the background, without taking the cursor or the focus away from you. The sandbox gives Linux, macOS, Windows or Android behind a single API, locally under QEMU or in the maintainers' cloud. Cua-Bench runs OSWorld and similar evaluations and exports trajectories for training. Lume creates macOS virtual machines on Apple Silicon using Apple's own virtualisation.

mcp-agent — Agents assembled from the patterns in Anthropic's "Building Effective Agents", with MCP as the only tool interface

Thu, 27 Aug 2026 00:00:00 GMT

mcp-agent makes a narrow bet: if every tool an agent needs arrives over MCP, the framework can be small. It handles the tedious half of that — opening, holding and closing connections to MCP servers — and then supplies the well-known compositions from Anthropic's "Building Effective Agents" as pieces you can nest: a router that picks a specialist, an orchestrator that plans and delegates, an evaluator that sends work back for another pass. The same agent can be published as an MCP server itself. For runs that must survive a crash it can execute on Temporal, which brings pause and resume at the cost of a service to operate.

mcp-use — Write an MCP server in TypeScript, bind React views to its tools, and inspect the result in a browser before shipping

Thu, 27 Aug 2026 00:00:00 GMT

Most MCP servers return text and leave the client to render it. mcp-use is built around the opposite idea: a tool can carry a React view, so what the user sees inside ChatGPT or Claude is an interface rather than a paragraph. Tool inputs and outputs are declared with Zod schemas and those types flow through to the view's props, so a change in one place shows up as a type error in the other. A scaffolded project comes with an inspector at a local URL for calling tools and looking at views while you work, and a tunnel for testing against a real client. Version 2 is a rewrite around this server-and-view model; the earlier Python client library is no longer where the project's attention is.

MemPalace — Keeps what was actually said, word for word, and organises the index instead of summarising the content

Thu, 27 Aug 2026 00:00:00 GMT

Most memory systems make an agent decide what was worth remembering and store its summary, which means a detail nobody thought important is gone by the time it matters. MemPalace takes the other route: conversations are kept verbatim, and the structure goes into the index rather than the content — people and projects become wings, topics become rooms, the original text sits in drawers — so a search can be aimed at part of the archive instead of run flat against everything. It runs on your machine, exposes itself over MCP so a coding agent can search it directly, and can sit on Chroma, SQLite, Milvus, Qdrant or Postgres. Mining is something you run, not something that happens by itself.

Midscene.js — Writes UI tests as sentences and drives the screen from the pixels, so there are no selectors to fix after a refactor

Thu, 27 Aug 2026 00:00:00 GMT

UI tests break for reasons that have nothing to do with the product: a class name changed, a wrapper was added, a component moved. Midscene removes the selector entirely. Steps are written as sentences, the model locates elements from the screenshot, and assertions can be about what a person would see — the row is highlighted, the layout has not collapsed — rather than about whether a node exists. That also reaches surfaces the DOM cannot: canvas drawings, icon-only buttons, native mobile applications, cross-origin frames. The trade is per-step cost and determinism, because each step is now a model call rather than a lookup, so a suite that runs in seconds with selectors will not run in seconds here.

MLflow — The experiment tracker teams already run, extended to hold agent traces, judges and prompt versions too

Thu, 27 Aug 2026 00:00:00 GMT

MLflow's usefulness for agents comes from where it already is: many organisations run it for model training, and the GenAI half puts agent traces, evaluation runs and prompt versions in that same experiment view. Instrumentation is automatic for a long list of agent libraries — one line and every prompt, retrieval, tool call and response is recorded, in OpenTelemetry's GenAI conventions so the traces are readable by other tools too. From there the recorded runs become evaluation sets, scored by built-in judges or ones you write. The cost is that MLflow is a platform, not a library: even for traces alone you are running a tracking server with a database and an artifact store behind it.

PaddleOCR — Turns scans, photographs and PDFs into Markdown or JSON an agent can read, in a hundred languages and on a CPU

Thu, 27 Aug 2026 00:00:00 GMT

Retrieval over your own documents usually fails long before the model does, at the point where a scanned table or a two-column PDF becomes an unreadable wall of text. PaddleOCR is the layer that stops that. It recognises text in more than a hundred languages, and its document pipeline preserves what the layout meant — headings stay headings, a table comes out as a table with its cell positions, formulas and seals are handled — emitting Markdown or JSON. The models are deliberately small enough to run on a CPU or at the edge, which is what makes processing a large archive affordable. The cost is the framework underneath: this is a PaddlePaddle project, and installing it means installing that.

PageIndex — Retrieval with no vector database: build the document a table of contents and let the model read its way in

Thu, 27 Aug 2026 00:00:00 GMT

Vector search finds passages that resemble the question, and resemblance is not relevance — on a long regulatory filing the paragraph that answers a question often shares almost no vocabulary with it. PageIndex drops the vector store. It builds a tree of the document's real structure, section by section, and then has a model walk that tree the way a person would use a table of contents: narrowing down, opening the part that should hold the answer, reading it. Nothing is chunked, and every answer points at the section it came from. The trade is per-query cost, since retrieval now involves reasoning rather than a lookup, and the design targets long individual documents rather than a corpus of short ones.

PocketFlow — The entire framework is about a hundred lines you can read in one sitting — everything else is yours to write

Thu, 27 Aug 2026 00:00:00 GMT

PocketFlow is a reaction to frameworks you cannot see the bottom of. The whole thing is roughly a hundred lines with no dependencies: a node does one piece of work in three phases — gather what it needs, do the work, decide what happens next — and the string a node returns picks which edge to follow. Nodes share one plain dictionary. That is the framework. There is no model client, no retry policy for a provider's particular errors, no tracing; you write those, and the cookbook of worked examples stands in for a reference manual. It suits people who would rather own a small amount of code than configure a large amount of someone else's.

Portkey AI Gateway — One endpoint in front of every provider, with the retries, fallbacks and cost controls agents make necessary

Thu, 27 Aug 2026 00:00:00 GMT

Agents call models far more often than a chat application does, which turns a provider's occasional rate limit into a daily outage. Portkey's gateway sits between your code and the providers and absorbs that: a failed call retries, a rate-limited key gives way to another, an unavailable model falls back to a second choice, and repeated prompts can be served from a cache instead of being paid for twice. Routing rules can send different requests to different models — cheap for classification, expensive for the hard step — without that decision spreading through your code. The project states it adds under a millisecond of latency in a footprint of about 122KB. One thing to check before planning around a feature: the documentation describes the open gateway and the company's hosted platform together.

Ragas — Scores retrieval on two questions: did it find the right passages, and did the answer stay inside them

Thu, 27 Aug 2026 00:00:00 GMT

The failure most retrieval systems have is invisible from the outside — the answer reads well and is not supported by anything that was retrieved. Ragas measures that directly. It splits the pipeline in two and scores each half: whether the retrieved passages actually contained what was needed, and whether the generated answer stayed within them. It can also build a starting test set out of your own documents, so the first evaluation does not wait for someone to hand-write a hundred questions. Nearly every metric is itself a model call, which is the thing to plan around: a full run costs money, and two runs on the same data will not produce identical numbers.

Rig — Build agents in Rust, with tool arguments and model output checked by the compiler rather than at run time

Thu, 27 Aug 2026 00:00:00 GMT

Rig is the answer for teams whose service is already Rust and who do not want a Python sidecar just to call a model. Tools are Rust functions, and their argument definitions are generated from the types, so a mismatch is a compile error rather than a malformed call discovered in production. The same applies to output: an extractor asks the model for a value and hands back an ordinary Rust struct. Providers and vector stores sit behind traits, so swapping either is a configuration change. What you give up is the ecosystem — the evaluation, tracing and agent tooling that exists ten times over in Python often has no Rust equivalent, and you will write more of the surrounding machinery yourself.

SkillSpector — Reads an agent skill before you install it and reports what it would be able to do to your machine and your data

Thu, 27 Aug 2026 00:00:00 GMT

Installing a skill or an MCP server is closer to installing a browser extension than to adding a library: it arrives as instructions and scripts that an agent will follow with your credentials and your files in reach, and almost nobody reads them first. SkillSpector reads them. It scans a repository, archive or directory against a catalogue of patterns covering prompt injection, data being sent somewhere it should not go, privilege escalation, poisoned tool descriptions and supply-chain risk, then returns findings with a score and a recommendation. NVIDIA cites research finding vulnerabilities in 26.1% of skills examined and likely malicious intent in 5.2%. A pattern scanner reports suspicion rather than proof, so expect to review findings and record the ones you have accepted.

Strands Agents — You write the tools and the prompt; the model runs the loop and decides when it is finished

Thu, 27 Aug 2026 00:00:00 GMT

Strands Agents takes the opposite bet from the graph frameworks. You supply a system prompt and a handful of ordinary functions marked as tools, and the model decides which to call, in what order, and when to stop. A first agent is a few lines rather than a wiring diagram — and when a run goes somewhere odd there is no graph to point at, so you read the trace instead. Around that loop sit the pieces a long-running agent needs: hooks that fire at every step so you can log or refuse a tool call, conversation managers that trim or summarise history before it reaches the model's limit, and ways to hand one agent to another as a tool.

AG-UI — The third agent protocol — not agent to tool, nor agent to agent, but agent to user interface

Fri, 21 Aug 2026 00:00:00 GMT

A request-and-response API cannot describe an agent that runs for minutes, streams partial work, changes its mind and occasionally needs a person. AG-UI defines that exchange as a stream of events over HTTP and WebSockets: tokens, tool calls and their results, shared state, attachments, and interrupts where the run stops to ask. Its usefulness scales with what already implements it — a first-party list that includes several frameworks in this catalogue — and drops sharply if neither your backend nor your frontend does.

Agent Framework — Microsoft's declared successor to both AutoGen and Semantic Kernel, for .NET and Python

Fri, 21 Aug 2026 00:00:00 GMT

Written by the teams behind both predecessors, it keeps AutoGen's light agent abstractions and adds Semantic Kernel's session state, middleware and telemetry, then puts graph-based workflows on top for cases where the execution path should be explicit rather than left to a model. For a .NET team this is the first-party answer that previously did not exist. The cost is timing: it is young, and code already running on either predecessor faces a migration rather than an upgrade.

AI SDK — The layer most TypeScript AI apps sit on: one call shape across twenty-odd model providers

Fri, 21 Aug 2026 00:00:00 GMT

Four functions carry most of the work — generateText and streamText for prose, generateObject and streamObject for data shaped by a schema — and they keep the same signature whether the model behind them is OpenAI, Anthropic, Google, Bedrock or a local one. A second half supplies framework hooks so a streaming chat UI is a few lines rather than a hand-rolled parser. It is a model-access and UI layer, not an agent runtime: persistent memory, retrieval and durable orchestration are somebody else's job.

AutoGPT — The 2023 autonomous-agent project, rebuilt as a block-based visual builder with a hosted twin

Fri, 21 Aug 2026 00:00:00 GMT

An agent here is a graph of blocks — one block calls a service, transforms data, prompts a model or branches — assembled on a canvas rather than written in code, then run on demand, on a schedule or from a trigger. One repository holds both the free self-hosted platform and the code behind the paid hosted one, and that is the catch: everything under the platform directory is PolyForm Shield, which permits use but forbids offering it as a competing product.

Codex CLI — OpenAI's own terminal coding agent, written in Rust and fenced in by the operating system

Fri, 21 Aug 2026 00:00:00 GMT

It works the way the other terminal agents do — read the repository, propose changes, run commands — but the boundary it enforces is unusual: on macOS and Linux it uses operating-system sandboxing to restrict which files and commands the agent can reach, so the limit does not depend on the model choosing to respect it. Sign-in runs through a ChatGPT plan or an OpenAI API key, which is the trade: the code is Apache-2.0, the model behind it is not the open part.

Crush — A single-binary terminal agent from the Charm terminal-UI people, source-available until it turns MIT

Fri, 21 Aug 2026 00:00:00 GMT

It installs as one Go binary from almost any package manager and runs on an unusually wide set of systems, including Windows PowerShell, WSL, Android and the BSDs. Inside, sessions are per project, the model can be swapped mid-conversation without losing context, and language servers feed it the same code intelligence an editor would. The licence is the thing to read first: it is not OSI-approved, it forbids offering a competing product, and each release only becomes MIT two years after it ships.

DeepEval — Evaluation written as unit tests, so a worse prompt or a swapped model fails CI like broken code

Fri, 21 Aug 2026 00:00:00 GMT

The shape is deliberately pytest's: assertions inside test functions, a runner that discovers them, parameterised cases — except the assertion is about whether an answer was faithful to its context or whether an agent finished the task. That framing is the point, because it puts quality regressions in front of the same gate that catches syntax errors. The thing to plan for is that most of these metrics are scored by a model, so the suite has a bill and a variance that ordinary tests do not.

Docling — Converts PDFs, Office files and scans into one structured representation, without sending them anywhere

Fri, 21 Aug 2026 00:00:00 GMT

The difference from a text extractor is that structure survives: page layout, reading order, table cells, code blocks and formulas come through as parts of a single document representation rather than as a flattened string, which is what decides whether a table in a report is still a table by the time an agent reads it. Everything can run locally, including in air-gapped environments. The cost of that fidelity is compute — machine-learning models run over each page, so this is a pipeline to budget for, not a fast converter to call inline.

Faiss — The similarity-search library that sits underneath the vector databases — an algorithm, not a product

Fri, 21 Aug 2026 00:00:00 GMT

It is built around an index that holds a set of vectors and searches them, and the dozens of available index structures exist because the trade-offs are real: search time against result quality against memory per vector against how long the index takes to build, and whether it needs training data at all. Some methods keep only a compressed representation and never the original vectors, which is how a single server reaches billions of them. There is no server, no filtering and no access control here — those are what the databases built on top of it add.

FastMCP — The Python framework most MCP servers are written in, well ahead of the copy inside the official SDK

Fri, 21 Aug 2026 00:00:00 GMT

A decorator over a typed Python function is a complete tool: the schema is derived from the type hints and docstring, and both the arguments coming in and the value going out are validated for you. Beyond that it covers the parts a second week of work runs into — a typed client, OAuth and remote identity providers, mounting several servers as one, proxying an existing server, and middleware. The confusion to be aware of is the name: an earlier version of this API was absorbed into the official MCP Python SDK, so FastMCP refers to two different things depending on which import you read.

garak — A vulnerability scanner for anything built on a language model: probes attack, detectors judge, a report follows

Fri, 21 Aug 2026 00:00:00 GMT

Point it at a chatbot or a model and it works through families of attacks — prompt injection, jailbreaks, encoding-based bypasses, data leaks and replay, toxicity, false reasoning — and reports which ones got through. Keeping the attacks, the judgement and the connection to the target as separate components is what lets a new probe or a new backend be added without rewriting the rest. It is the finding half of security, not the fixing half: the output tells you which probes succeeded, not what policy to write in response.

GEPA — Improves prompts by reading why a run failed, rather than by scoring how badly it did

Fri, 21 Aug 2026 00:00:00 GMT

Reinforcement learning compresses an entire execution into one number, which throws away the part that says what went wrong. GEPA keeps it: error messages, profiling output and reasoning logs go back to a model that diagnoses the failure and proposes a specific edit, and it maintains a frontier of candidate prompts each strong on different examples rather than collapsing to one winner. The project reports reaching results in 100 to 500 evaluations where reinforcement learning needs upwards of 10,000. Both the running and the reflecting are model calls, so the efficiency is relative to RL, not to zero.