Atlas of admitted work

Open-source coding agent CLI/TUI with providers, skills, and MCP.

Highest-velocity open coding agent. Useful as a harness reference; quality-filter the plugin ecosystem.

Fair-code workflow automation with native AI nodes, MCP client/server, 400+ integrations.

The DAG half of agentic systems, mature before agents existed. Factor 8 in product form.

Web → markdown/JSON at agent scale. Search, scrape, crawl as context acquisition.

The practical 'read the web' tool. Pair with a sandbox; do not let the agent browse raw HTML unaided.

Agent Skills format: YAML frontmatter, progressive disclosure, scripts/references/assets.

The canonical skill spec. Every serious harness now loads name+description always, body on trigger, files on demand.

Visual agentic workflows + RAG in one collaborative workspace. Cloud or self-host.

Highest-star visual builder that actually reaches production teams. Use when the org is not a code shop.

The agent engineering platform: models, tools, retrievers, and the Deep Agents / LangGraph stack.

Largest ecosystem and integration surface. Use as a library of parts, not as an all-or-nothing religion.

OpenAI's local coding-agent CLI: sandbox, exec, AGENTS.md, skills, plan/act.

A first-party harness to study alongside Claude Code, OpenHands, and Cline. Git as ledger, approval as a product.

Playwright-backed browser agent: DOM as the ACI for web tasks.

Default open computer-use for the web. Study the action space; keep it sandboxed.

Terminal agent with MCP client/server and ReAct-style tools, first-party Gemini.

Google's open coding agent. Clean MCP-native design; study the tool surface.

Production-grade engineering skills for coding agents — review, testing, architecture, not toy prompts.

Highest-signal skill corpus after Anthropic's own. Treats agents as engineers with checklists, not chatbots.

Full coding-agent runtime: sandbox, browser, editor, PR loop. The open Devin.

Most complete open software-engineering agent. Study its event stream and sandboxing, not just the UI.

Long-horizon SuperAgent: sandboxes, memory, skills, subagents, message gateway on LangGraph.

ByteDance's production-shaped research/code/create harness. The gateway + subagent split is the lesson.

Living textbook of prompting, RAG, and agent patterns with papers and notebooks.

Longest-running, best-maintained public syllabus. Use for vocabulary, not as a runtime.

Eighteen lessons covering AutoGen, Semantic Kernel, Foundry, and agentic RAG.

Microsoft's official on-ramp. High pedagogical density; pairs with Agent Framework for production.

Software-company simulation: SOPs as prompts, PM → architect → engineer → QA assembly line.

The canonical society-of-mind coding org. SOP-as-code is the lasting idea; the company metaphor is the demo.

Autonomous coding agent as SDK, IDE extension, and CLI. Plan/act modes, MCP.

The most copied IDE-agent architecture after Cursor. Human-approval gates done well.

Field notes from vibe-coding to agentic engineering: CLAUDE.md, skills, commands, agents.

Highest-starred practice guide specifically named agentic engineering. Operational, not theoretical.

Conversational multi-agent: agents talk, group chat, GraphFlow, human proxy.

Invented the agents-talking-to-agents pattern at research scale. Predecessor to Microsoft Agent Framework.

Role / goal / backstory crews plus deterministic Flows. Hierarchical or sequential process.

Fastest way to express a role-based team. Best when tasks are nameable; Flows for when they must be reliable.

Native open agent — desktop, CLI, API. Recipes, extensions, provider-agnostic.

Independent harness that is not a Claude Code clone. Useful for recipe/extension design and local-first agents.

Document agents: indexes, query engines, agentic RAG over private data.

The data-facing half of the agent stack. Prefer when the hard problem is corpus, not orchestration.

Git-native pair programmer: repo map, conventional commits, watch files, code edit formats.

Invented practical repo-map context. Still the best study of how to edit code as a tool, not a chat dump.

AgentOS: fast instantiation, multimodal, self-hosted control plane with RBAC and scheduling.

Independent framework with a real runtime, not just a loop helper. Performance-first design.

Memory layer with extraction, not transcript dumps. User-scoped, inspectable.

The practical alternative to 'save the log'. Pair with Letta's architecture ideas.

Durable graph runtime: nodes, edges, checkpoints, streaming, human-in-the-loop, time travel.

The production default for stateful agents. Klarna-scale deployments. Cycles + persistence are first-class.

Programming, not prompting: modules + teleprompters that optimize prompts/weights against metrics.

The only mainstream library that treats prompt quality as an optimizer's job. Use when you have evals.

Open-source LLM observability: traces, evals, prompt management, datasets.

You cannot improve what you cannot see. The default self-hosted tracing plane.

Free course on smolagents, tools, and evaluation with runnable units.

Best open course that actually makes you implement a code-act agent, not just read about one.

Open IDE agent: context providers, edit tools, rules, model-agnostic autocomplete + agent.

The IDE-native cousin of Cline. Study context providers and the rules file, not the branding.

Lightweight harness: agents, handoffs, guardrails, tracing. Successor spirit of Swarm.

Smallest serious multi-agent SDK. Handoffs as first-class. Prefer this over Swarm for new OpenAI-stack work.

Code-act agents: the model writes Python to use tools instead of JSON tool calls.

Proves that code is often a better action language than JSON. Minimal core, serious idea.

Batteries-included harness: planner, filesystem, subagents, on LangGraph.

The open-source crystallization of the 'Claude Code shape' — planning + files + subagents — as a library.

TypeScript-native agents and workflows with evals, MCP, suspend/resume.

Best TS-first framework if you refuse to leave Node. Workflows as state machines, not Python ports.

Plugins, planners, and process framework. Ancestor of Microsoft Agent Framework.

Still the .NET-native plugin model. New work should prefer Agent Framework; read SK for the plugin ACI.

Skills catalog for Codex. The open skill format crossing Claude and Codex.

Confirms progressive disclosure as a cross-vendor standard, not an Anthropic-only file layout.

Provider-agnostic TypeScript toolkit: streaming, tool parts, typed agents. The TS default for the loop.

If you are in Node/React, this is the thinnest way to own prompts and stream the loop. Not an orchestrator religion.

The production principles: own prompts, context, control flow; agent as stateless reducer.

The most cited engineering doctrine for customer-facing agents. Distills what actually ships versus what demos well.

Agent2Agent protocol: opaque agents discover, auth, and task across vendors (Linux Foundation).

The interoperability layer MCP does not cover — agent-to-agent, not agent-to-tool.

Managed tool catalog across SaaS APIs, with auth. Tools as a product, not a pile of wrappers.

Study the ACI of a large tool marketplace — and the poisoning risk of installing all of them.

Declarative evals and red-teaming for prompts, agents, RAG. CI-native.

Used by OpenAI and Anthropic internally for evals. Treat evals as tests, not vibes.

Stateful agents with self-editing memory (MemGPT lineage). Core vs archival memory.

The memory architecture paper made runnable. Default citation for long-horizon stateful agents.

Official Python SDK for MCP servers and clients — tools, resources, prompts.

The USB-C of agent tools. Implement against the spec, not against a vendor's wrapper.

Educational handoff model: routines + agents that transfer control by returning another agent.

The cleanest explanation of handoffs ever written. Read it; ship with the Agents SDK.

Code-first Agent Development Kit: workflow agents + LLM-routed hierarchy, eval, GCP deploy.

Google's first-party kit. Hybrid orchestration (deterministic + delegated) is the right default on Gemini.

Typed agents end-to-end: Pydantic models as the contract with the LLM.

Best-in-class type discipline. If you already live in Pydantic, this is the least surprising agent library.

Agents as Durable Objects: identity, state, scheduling, hibernation on the edge.

Factor 6 and 12 as infrastructure. The agent is a principal with a stable address, not a lambda that forgets.

Typed, atomic browser actions over Playwright. An ACI for the DOM, not a screenshot loop.

Computer-use that prefers structured actions. Pair with a sandbox; keep it off the first-tool list.

Skill pack for context windows, multi-agent isolation, and production debugging of context rot.

The only high-review corpus that treats context engineering as a first-class skill family rather than a blog post.

Role-playing communicative agents; research platform for agent societies and scaling laws.

First serious multi-agent role-play paper/code. Use for research topologies, not as a product runtime.

UK AISI eval framework: agents, scorers, sandboxes, traces. Research-grade measurement.

The other eval default next to promptfoo. Use when the task is an agent trajectory, not a prompt pair.

Temporal knowledge graphs for agent memory. Facts with time, not a vector soup.

When memory must be inspectable and time-aware. Complements Letta and mem0; does not replace a context builder.

Structured outputs as Pydantic models, any provider. The ACI as a type.

Best small library for 'the model must return this schema'. Complements Pydantic AI; do not skip Factor 4.

MicroVM sandboxes for untrusted agent code. Firecracker-class isolation as a product.

The production answer to 'the agent wants a shell.' Boundaries at the sandbox, not the prompt.

Unified successor to AutoGen + Semantic Kernel. Python and .NET, graph workflows, handoffs.

Microsoft's production consolidation. Use this, not AutoGen, for new Azure / .NET work.

Durable functions and event-driven runs. Pause, resume, fan-out as product primitives.

Factor 6 without buying a graph framework. The loop is a function that can sleep and wait on a human.

Anthropic-catalog workflows composed over MCP: chain, parallel, router, orchestrator, evaluator.

The workflow catalog as code, with MCP as the tool bus. A clean reference if you refuse a heavier graph runtime.