13: The open-source ecosystem¶

About a 35-minute read. Last checked November 8, 2026.

TL;DR - "Open source" in AI tooling covers several layers: inference runtimes, agent frameworks, harnesses, MCP servers, skills, orchestrators and eval tools. An open-source harness can drive a closed model, and an open-weight model can run in a closed harness. - Open-source coding harnesses include OpenCode, Aider, Cline, Kilo Code, goose, OpenHands, and the open-source CLIs from OpenAI (Codex CLI) and Google (Gemini CLI). Roo Code shut down in May 2026, and Continue was archived. - OpenClaw (formerly Clawdbot, then Moltbot) became one of GitHub's most-starred projects in early 2026. It showed real demand for personal agents that live in your messaging apps, and what happens when one is exposed to the internet and uses an unvetted skill registry. - You rarely need an agent framework to start, since a working agent loop is about 30 lines. Reach for LangGraph, Pydantic AI, the OpenAI Agents SDK, the Claude Agent SDK and similar tools when you need durable state, tracing, many tools, or many agents. - AI has put a heavy load on maintainers. curl ended its bug bounty in January 2026 after confirmed reports fell below 1 in 20. Projects now publish AI policies ranging from outright bans (Gentoo, QEMU) to "disclose it and own it" (LLVM, Ghostty, the Linux kernel). - Contribute with AI the way you'd want others to contribute to your project: understand every line, disclose AI use, keep pull requests small, write the description yourself, and follow the project's policy.

Foundations¶

What "open source" means here¶

Two kinds of openness get mixed up:

Open-weight models publish the trained weights so you can run or fine-tune them yourself. Module 04 covers them.
Open-source software publishes the source code of a tool under a license that lets you read, modify and redistribute it. This module is about the software.

The two are independent. Codex CLI is open-source software that by default calls OpenAI's closed models. OpenCode or Aider can drive a closed frontier model or a local open-weight model. A closed IDE can run an open-weight model.

Licenses you'll meet:

License	What it allows	Seen on
MIT	Almost anything, with attribution	OpenCode, Kilo Code, OpenHands, T3 Code, Gas Town, Beads, Inspect
Apache-2.0	Almost anything, with attribution, plus an explicit patent grant	Codex CLI, Gemini CLI, Aider, Cline, goose
FSL-1.1-MIT (Functional Source License)	Source-available: use and modify, but no competing commercial product; each release converts to MIT after two years	Crush

Some projects mix licenses. Cline's JetBrains plugin isn't open source, for example, even though its VS Code extension is (Cline README). Read the license file, not the marketing page.

Open source matters here for a few reasons. You can read a harness's system prompt and tool code, which is the best way to understand what it does. You can run it where your code lives, including air-gapped or on-premises environments with local models. It's also the industry's research lab: ideas such as Aider's repository map, the Ralph loop, worktree-per-agent orchestration, and git-backed agent memory appeared in open projects first and were copied everywhere within months.

Open source also offers some protection against vendor churn. You can still run an archived tool. A shut-down service is unavailable.

A map of the stack¶

flowchart TB
    M["Models<br/>(open-weight or API; modules 03–04)"]
    I["Inference runtimes<br/>llama.cpp · Ollama · vLLM · SGLang · MLX"]
    F["Frameworks and SDKs<br/>LangGraph · Pydantic AI · DSPy · OpenAI Agents SDK · Claude Agent SDK · ..."]
    H["Harnesses<br/>OpenCode · Aider · Cline · Kilo Code · goose · OpenHands · Codex CLI · ..."]
    X["Extensions<br/>MCP servers · Agent Skills · plugins"]
    O["Orchestrators and GUIs<br/>Gas Town · Beads · OpenHands Agent Canvas · T3 Code"]
    E["Evaluation<br/>SWE-bench harness · Inspect · promptfoo"]
    M --> I --> F --> H
    X --> H
    H --> O
    E -. measures .-> H
    E -. measures .-> M

You don't need every layer. A typical engineer uses one harness, a few MCP servers and skills, and an API or subscription model. Someone running models locally adds a runtime. Someone building a product adds a framework or SDK and an eval tool.

In practice¶

Open-source coding harnesses¶

Statuses and star counts are as of November 2026. Stars measure attention, not quality. Crush is included for comparison but is source-available under the FSL, not open source.

Project	Maintainer	Form	License	Notes
OpenCode	The `anomalyco` org (the SST team)	Terminal UI; desktop app in beta	MIT	Model-agnostic and very popular (about 225K stars). Kilo Code's CLI is a fork of it
Codex CLI	OpenAI	CLI (written mostly in Rust), IDE extension	Apache-2.0	Open-source client for OpenAI's closed models; same agent as the Codex app
Gemini CLI	Google	CLI	Apache-2.0	Since June 18, 2026, aimed at enterprise Gemini Code Assist. Individual users were moved to Antigravity CLI
Aider	Paul Gauthier and contributors	CLI	Apache-2.0	One of the first terminal pair-programmers (2023). Pioneered the repository map and a git commit per change
Cline	Cline Bot Inc.	VS Code extension, CLI, SDK, desktop app; JetBrains plugin (closed)	Apache-2.0	Began in 2024 as "Claude Dev." Shows diffs for approval; any provider
Kilo Code	Kilo-Org	VS Code, JetBrains, CLI	MIT	Started in the Cline and Roo Code family of extensions; many models, no markup on provider prices
goose	Block, now part of the Agentic AI Foundation	Desktop app, CLI, API	Apache-2.0	A general-purpose local agent, not only for code. Built around MCP extensions. A founding AAIF project
OpenHands	All Hands AI	Web UI ("Agent Canvas"), CLI, cloud, SDK	MIT	Formerly OpenDevin (Wang et al., 2024). Now also a control center that can run Claude Code, Codex, Gemini CLI and OpenCode
Crush	Charm	Terminal UI	FSL-1.1-MIT	LSP-aware, MCP support, switch models mid-session
T3 Code	Ping (Theo Browne)	Desktop, web and mobile GUI over CLI agents	MIT	Not an agent itself; drives the agent CLIs you already have (module 06)
Roo Code	Roo Code Inc.	VS Code	Apache-2.0	A fork of Cline. Shut down May 15, 2026; repository archived. The team pivoted to a cloud product and pointed users to Cline or the community fork ZooCode
Continue	Continue Dev	VS Code, JetBrains, CLI	Apache-2.0	Archived and read-only in 2026 after a final 2.0 release

Other labs ship open-source CLIs too. Alibaba's Qwen Code, for example, was one of the three agents in the ETH Zurich AGENTS.md study (module 07).

For one terminal agent that works with any model, start with OpenCode or Aider. If you live in VS Code and want to approve each diff, try Cline or Kilo Code. goose is the general desktop agent, and OpenHands or T3 Code let you run and compare several agents. Whichever you pick, check its last release date and open-issue count first.

Case study: OpenClaw and personal agents¶

OpenClaw is an open-source personal assistant agent by Peter Steinberger. It runs on your own machine, connects to a model of your choice, and talks to you through messaging apps such as Signal, Telegram, Discord and WhatsApp. It can act on your email, calendar, files and accounts, and it extends itself with skills (folders with a SKILL.md, the same format as Agent Skills).

It changed names four times in about two months (Wikipedia):

Date	Name
Nov 24, 2025	First published as Warelay
Dec 3, 2025	Renamed CLAWDIS
Jan 2, 2026	Renamed Clawdbot
Jan 27, 2026	Renamed Moltbot after trademark complaints from Anthropic
Jan 30, 2026	Renamed OpenClaw

It grew faster than almost any project before it, passing 247,000 GitHub stars by early March 2026. Moltbook, a social network for AI agents launched by Matt Schlicht, rode the same wave. On February 14, 2026, Steinberger announced a move to OpenAI and said a non-profit OpenClaw Foundation would steward the project. OpenClaw 2.0 shipped on August 30, 2026.

OpenClaw exposed several demands and risks:

People want an agent that lives where they already talk, keeps memory between sessions, and can act across their accounts. That's a different product from a coding agent.
A personal agent is the lethal trifecta in one package. It reads untrusted content (emails, messages, web pages), holds private data, and can send messages and take actions. Those three together make prompt injection dangerous (module 11).
Deployment configuration is security policy. Security researchers reported tens of thousands of OpenClaw instances exposed to the internet in late January and early February 2026. Censys counted 21,639 on January 31, while Bitsight reported more than 30,000. Censys explicitly says the default listener was localhost, so the public exposure came from deployment choices, not an all-interfaces default.
A skill registry is a software supply chain. Koi Security reported auditing 2,857 skills on the public ClawHub registry and flagging 341 as malicious, most of them reportedly tied to one campaign that delivered password-stealing malware to macOS and Windows users (BleepingComputer). The maintainers responded with reporting tools, malware scanning, and minimum account ages for uploaders.
Institutions noticed. In March 2026 Chinese authorities reportedly restricted state agencies and state-owned firms from running OpenClaw on office computers. Reviewers of the 2.0 release still criticized it for not enabling its sandbox by default and not encrypting stored secrets.

An agent that can do everything on your behalf needs sandboxing, least-privilege credentials, vetted extensions, and confirmation before irreversible actions. The exposure counts alone don't tell you how many users had those controls.

Inference runtimes (running models yourself)¶

These run open-weight models on your own hardware. Module 04 covers which models to run and how much hardware you need.

Runtime	What it is	Reach for it when
llama.cpp	C/C++ inference engine and the GGUF quantized-model format; runs on CPUs, GPUs and Apple Silicon	You want maximum portability, or you're on a laptop
Ollama	A friendly wrapper: `ollama run <model>` downloads and serves a model with a local OpenAI-compatible API	You want the easiest local setup
vLLM	High-throughput GPU serving, built around PagedAttention (Kwon et al., 2023)	You're serving a model to a team or a product
SGLang	Fast serving with prefix caching (RadixAttention) and structured generation (Zheng et al., 2023)	You're serving agent workloads with lots of shared prompt prefixes
MLX	Apple's array framework for Apple Silicon, with `mlx-lm` for running and fine-tuning models	You're on a Mac and want speed or local fine-tuning

Most open-source harnesses can point at any of these through an OpenAI-compatible endpoint.

Agent frameworks and SDKs¶

A framework gives you building blocks for agents: model clients, tool definitions, memory, state, tracing, multi-agent coordination. An SDK from a lab gives you that lab's agent harness as a library.

Project	One line	Reach for it when
LangChain / LangGraph	LangChain provides integrations and building blocks. LangGraph builds stateful graphs with checkpoints and human-approval steps	You need explicit, durable, resumable workflows (module 07)
LlamaIndex	A data framework: ingest, index and query your documents, with agents on top	Your agent's main job is answering from your data
DSPy	Declarative modules plus optimizers that tune prompts (or weights) against a metric (Khattab et al., 2023)	You have an eval set and want to optimize prompts systematically instead of by hand
Pydantic AI	Type-safe Python agents from the Pydantic team, with validated structured outputs	You want typed inputs and outputs in a Python service
CrewAI	Role-based multi-agent "crews" with tasks and processes	You want to prototype a multi-agent design quickly
AutoGen / Microsoft Agent Framework / AG2	AutoGen pioneered conversational multi-agent programming (Wu et al., 2023). Microsoft has archived it and names Agent Framework its successor. AG2 is a community fork	New Microsoft-stack projects: Agent Framework. Existing AutoGen code: migrate
OpenAI Agents SDK	A lightweight SDK (March 2025) with agents, handoffs, guardrails and tracing	You're building on OpenAI models and want minimal abstraction
Claude Agent SDK	The harness behind Claude Code, as a library (renamed from the Claude Code SDK in September 2025): tools, permissions, hooks, subagents, MCP, skills	You want Claude Code's loop inside your own product or automation
Google ADK	Google's Agent Development Kit, designed to work with A2A	You're building on Gemini or Google Cloud
smolagents	A minimal library from Hugging Face whose "code agents" write Python as their actions	You want something small enough to read in an afternoon
Mastra	A TypeScript framework for agents, workflows, retrieval and evals	Your team works in TypeScript

Framework or just a loop?¶

Anthropic's Building effective agents warns that frameworks "often create extra layers of abstraction that can obscure the underlying prompts," and suggests starting with direct API calls. Here's a minimal agent loop with one tool, a permission check, truncated tool output and a turn budget, using the Anthropic Python SDK. Other providers' SDKs look about the same.

import os, subprocess
import anthropic

client = anthropic.Anthropic()
MODEL = os.environ["AGENT_MODEL"]  # choose a current model; see module 03

TOOLS = [{
    "name": "bash",
    "description": "Run a shell command in the repository. Returns stdout and stderr.",
    "input_schema": {
        "type": "object",
        "properties": {"cmd": {"type": "string"}},
        "required": ["cmd"],
    },
}]

def run(cmd: str) -> str:
    if input(f"run `{cmd}`? [y/N] ").strip() != "y":  # the permission system
        return "The user declined to run this command."
    p = subprocess.run(cmd, shell=True, capture_output=True, text=True, timeout=120)
    return (p.stdout + p.stderr)[-10_000:]  # crude context management

messages = [{"role": "user", "content": "Make the failing test in tests/ pass."}]
for turn in range(30):  # a budget, so it can't run forever
    resp = client.messages.create(model=MODEL, max_tokens=4096,
                                  tools=TOOLS, messages=messages)
    messages.append({"role": "assistant", "content": resp.content})
    if resp.stop_reason != "tool_use":
        print("".join(b.text for b in resp.content if b.type == "text"))
        break
    messages.append({"role": "user", "content": [
        {"type": "tool_result", "tool_use_id": b.id, "content": run(b.input["cmd"])}
        for b in resp.content if b.type == "tool_use"
    ]})

This teaching example has no sandbox, total-context limit, or error recovery, and the shell tool runs whatever command you approve, so run it only in a disposable environment without real credentials. A production harness adds controls such as sandboxing, compaction, hooks, and recovery (module 06).

A plain loop is enough when there's one agent, a handful of tools, and short sessions. Move to a framework or SDK when you need state that survives restarts, tracing and observability in production, many tools or many agents, human approval steps in the middle of a workflow, or systematic prompt optimization (DSPy). If what you want is "a coding agent, but scripted," use an existing harness such as the Claude Agent SDK, Codex CLI in headless mode, or OpenCode.

MCP servers worth knowing¶

For background on MCP, read module 06. Some servers to know:

The reference servers in modelcontextprotocol/servers: Everything (a test server), Fetch, Filesystem, Git, Memory, Sequential Thinking and Time. Many earlier reference servers (GitHub, Slack, Postgres, Puppeteer and others) moved to an archive repository as vendors shipped official ones. The README calls the reference servers educational examples, "not production-ready solutions."
GitHub's official MCP server covers issues, pull requests, code search and Actions, and runs locally or as a hosted server.
Playwright MCP (Microsoft) automates a browser through the page's accessibility tree, so an agent can test the web app it just built.
Chrome DevTools MCP (Google) gives an agent console logs, network requests and performance traces from a real Chrome instance.
The MCP Registry is the official catalog for finding published servers.

Prefer servers maintained by the service's own vendor. Read a server's tool descriptions before you connect it, because they go straight into your agent's context, and give each server the narrowest credentials that work.

Skill collections¶

anthropics/skills (about 190K stars) holds Anthropic's examples, including the document skills (Word, PDF, PowerPoint, Excel) behind Claude's file features, a skill template, and the specification. Install it in Claude Code with /plugin marketplace add anthropics/skills, and check each skill's license.
obra/superpowers (Jesse Vincent) is a popular community library of workflow skills such as test-driven development, planning and systematic debugging.
The Agent Skills specification is the open format, now governed by the Agentic AI Foundation, so a skill written for one harness works in others.

A skill is instructions, often with scripts your agent will run. The ClawHub incident shows what happens when people install skills like browser bookmarks. Read a skill before you install it, and pin versions for team use.

Orchestration projects¶

Gas Town (Steve Yegge, January 2026, MIT) is a workspace manager for running 20–30 coding agents at once, with a deliberately colorful vocabulary. A Mayor agent takes your request and assigns work. Polecats are worker agents, Rigs wrap repositories, and a Witness watches for stuck agents. A Refinery batches and verifies finished work before merging. Claude Code is the default runtime, and Gas Town also supports Codex, Gemini, Cursor, Amp, OpenCode and others. Yegge's eight-stage ladder of AI coding workflows, from the same launch essay, is in module 08.
Beads (Steve Yegge, MIT) is a graph issue tracker for agents, backed by the version-controlled database Dolt. Agents create tasks, record dependencies, find unblocked work, claim it and close it. It replaces sprawling markdown plan files with structured memory that many agents can share, and Gas Town depends on it.
OpenHands Agent Canvas and T3 Code sit one level down. They're GUIs for running and supervising several agents, without Gas Town's autonomous coordination.

Evaluation tooling¶

Module 05 explains benchmarks and how to build your own evals. These open tools run them:

The SWE-bench harness (Jimenez et al., 2023) runs an agent's patch against a real repository's tests in Docker. Use it to reproduce published numbers or to test changes to your own harness.
Inspect (UK AI Security Institute, MIT) is a Python framework for evaluations including tool use, multi-turn dialogue and model-graded scoring, with more than 200 ready-made evaluations.
promptfoo is a CLI for testing prompts and models against test cases and for red-teaming. OpenAI announced it would acquire Promptfoo on March 9, 2026, and said the open-source project would continue.

The other side: AI slop and maintainer burden¶

Open source runs on volunteer review time. AI tools made it nearly free to produce a plausible-looking pull request or bug report, and the cost moved to maintainers, who must read every one.

Daniel Stenberg, curl's founder and lead developer, had complained about AI-generated security reports since early 2024. In January 2026, Stenberg announced the end of curl's bug bounty, effective January 31, and explained why on his blog on January 26. Over its life the program had confirmed 87 vulnerabilities and paid more than $100,000. But the share of reports that turned out to be real fell from above 15% in earlier years to below 5% from 2025 on: "Not even one in twenty was real." The money, Stenberg argued, drew in low-effort submissions, and "the never-ending slop submissions take a serious mental toll to manage." curl now takes reports through GitHub's private vulnerability reporting and email, with no payouts. The problem was unchecked reports.

Project policies fall on a spectrum:

Project	Policy	Key rules
Gentoo	Ban (Council vote, April 14, 2024)	No content created with AI assistance. Reasons given: copyright, quality, and ethics
QEMU	Decline	Will "DECLINE any contributions which are believed to include or derive from AI generated content." AI for research, static analysis or debugging is fine if its output isn't submitted
LLVM	Human in the loop	You must read and review all generated code before asking others to. Label substantial AI help (for example with an `Assisted-by:` trailer). Write your own PR description. No autonomous agents in project spaces. No AI on "good first issue" tickets. Maintainers can label a contribution "extractive." The golden rule: "a contribution should be worth more to the project than the time it takes to review it"
Linux kernel	Human accountability	"AI agents MUST NOT add Signed-off-by tags." Only a human can certify the Developer Certificate of Origin, and the human submitter takes full responsibility
Ghostty	Disclose and understand	"All AI usage in any form must be disclosed." You must fully understand your code. No AI-generated media. First-time contributors need a maintainer to "vouch" for them, or their PRs are closed automatically. "Bad AI drivers will be denounced" on a public list

Through 2026 the trend has been away from blanket bans and toward disclosure, accountability and protecting maintainer time. In all of them, a human must understand, stand behind, and be able to discuss every line they submit.

Etiquette for contributing with AI¶

Before you open a pull request or issue on someone else's project:

Read the project's CONTRIBUTING.md and AI policy. If they ban AI-generated contributions, don't submit them. If they require disclosure, disclose.
Understand every line. If you can't explain the change and its edge cases without the AI open, you aren't ready to submit it.
Reproduce the problem yourself. For bug and security reports especially, show a real reproduction on a real build. Don't forward a model's speculation.
Keep it small and focused, with one logical change per PR. Don't let an agent "also clean up" unrelated files.
Run the project's tests and linters locally. Never make the maintainers' CI find what you could have found.
Write the description and review replies yourself. Explain what you changed, why, and what you didn't verify. Maintainers want to talk to you, not your agent.
Disclose AI assistance even where it isn't required. Name the tool and say roughly how you used it.
Respect the maintainers' time. If a maintainer says no, accept it, and don't open the same PR again with a new prompt.
Never let an agent post autonomously to an issue tracker, pull request or mailing list on your behalf.

How students can contribute to open source with AI, responsibly¶

Contributing to open source is one of the best ways for a student to learn real engineering. AI can help you understand the project before you contribute.

Pick a project you use. You'll understand its users, and you'll care about the result.
Read the contributing guide and AI policy first. Note what's banned, what must be disclosed, and how to claim an issue.
Use AI to understand the code, not to submit it. Ask an agent to explain the architecture, trace a request through the code, or explain why a test is failing. This is the highest-value, lowest-risk use.
Choose an issue and say you're working on it before you write code. Some projects, LLVM for example, ask that newcomer "good first issues" be done without AI, because they exist to teach.
Reproduce the bug by hand, and write a failing test before you fix anything.
Write or heavily revise the fix yourself. If an agent drafts it, rework it until you could have written it, then delete what you can't defend.
Ask a different model or a classmate to review your diff before sending it to maintainers (module 10).
Write the PR description in your own words, and disclose how you used AI.
Handle review feedback yourself. Answer questions from your own understanding, and if you don't know, say so and go find out.
Keep a log of what you learned. For a course, that log, not the merged PR, is the evidence of learning (module 15).

Going deeper¶

Open source as the field's R&D lab¶

Many harness ideas that are now standard appeared first in open projects or public experiments. Aider's repository map (a compact summary of a codebase's symbols) showed that agents need a map rather than whole files. The Ralph loop showed how far a dumb outer loop with fresh contexts can go. Beads and Gas Town pushed git-backed, structured memory for many agents. The skills format began in Anthropic's public repository, and within a year a growing list of other agent products had adopted it (client showcase). Vendors watch these projects closely, and good ideas show up in commercial products within months (module 06).

Churn and capture¶

2026 was hard on open-source AI tooling:

Roo Code shut down its extension, cloud and router on May 15, 2026 and pivoted to a hosted product.
Continue was archived.
Gemini CLI stayed open source but stopped serving individual users, who moved to Google's Antigravity CLI.
AutoGen was archived in favor of Microsoft Agent Framework.
Promptfoo was bought by OpenAI, which said it would keep the project open.
OpenClaw's creator joined OpenAI, and the project moved to a foundation.

The pattern is familiar from earlier open-source eras. Venture-funded companies build open tools to win adoption, then pivot, sell or shut down. Open source means you can fork an abandoned project, but it doesn't mean anyone will maintain the fork. Neutral foundations such as the Agentic AI Foundation, which now hosts MCP, AGENTS.md, goose and Agent Skills, are one response. When you choose a tool, weigh its governance (one company, or a foundation with several members) as well as its features.

Open client, closed model¶

Several of the most-starred harnesses, such as Codex CLI and Gemini CLI, are open-source clients for closed models. Claude Code itself isn't open source, although its SDK wrappers are published on GitHub. With an open client you can read every prompt and tool, but the model is still a remote service with its own terms, rate limits and data policies. You can audit what's sent, fork the client, and swap in a different model where the harness allows it. The stack still depends on a closed model. For that, combine a model-agnostic harness, an open-weight model and a local runtime (module 04).

Extensions are dependencies¶

MCP servers, skills and plugins run with your agent's permissions. Treat them like any other dependency: check the maintainer, read the code, pin versions, prefer official vendor packages, and watch for updates that change behavior. The OpenClaw skill-registry malware and the MCP "tool poisoning" research are early examples of a supply-chain problem that will grow (module 11).

Bryan's take¶

Bryan's take: OpenClaw had a couple of issues, but it was Gas Town that really did not work for me.

Bryan's take: Having several agents or models review each other's work is valuable. That applies before you open a pull request on someone else's project too. Run a second reviewer over your diff before a maintainer has to.

Try it¶

Individual exercise: read a harness, then write one (2–3 hours). 1. Clone one open-source harness (OpenCode, Aider, Cline or Codex CLI). Find its system prompt and the definitions of its file-editing and shell tools. Write down three design choices that surprised you. 2. Run the 30-line loop from this module against a toy repository with a failing test. Add one improvement from the harness you read, such as a better edit tool, output truncation, or a deny list for dangerous commands. Measure whether it helps on three tasks. 3. Write a half-page comparison of your loop and the real harness.

Class or team exercise: the maintainer's chair (one session). The instructor prepares ten pull requests against a small project the class knows. Some are careful human work, some are careful AI-assisted work with disclosure, and some are unreviewed AI output. Students act as maintainers: they time each review, decide accept, revise or reject, and guess which PRs were unreviewed AI output. Then discuss: what made a PR cheap or expensive to review? Draft an AI-contribution policy for the project, and compare it with LLVM's and Ghostty's.

Discussion questions¶

Is an open-source harness that only works well with one vendor's closed model really "open"? What would you need for a fully open stack?
Roo Code, Continue and others were archived or shut down in 2026. How should a team decide whether to depend on an open-source AI tool?
Gentoo bans AI-generated contributions, while LLVM allows them with human review and disclosure. Which policy would you choose for a project you maintain, and why?
curl's confirmed-report rate fell below 1 in 20. Who should bear the cost of filtering AI-generated reports: reporters, platforms, AI vendors, or maintainers?
OpenClaw showed huge demand for personal agents and serious security problems. What would a "safe by default" personal agent have to do differently?
When does a framework like LangGraph or DSPy earn its complexity over a 30-line loop?

Sources and further reading¶

Papers - AutoGen: Enabling Next-Gen LLM Applications via Multi-Agent Conversation (Wu et al., 2023). - Efficient Memory Management for Large Language Model Serving with PagedAttention (Kwon et al., 2023): the paper behind vLLM. - DSPy: Compiling Declarative Language Model Calls into Self-Improving Pipelines (Khattab et al., 2023). - SWE-bench: Can Language Models Resolve Real-World GitHub Issues? (Jimenez et al., 2023). - SGLang: Efficient Execution of Structured Language Model Programs (Zheng et al., 2023). - OpenHands: An Open Platform for AI Software Developers as Generalist Agents (Wang et al., 2024).

Primary sources: projects - Harnesses: OpenCode, Codex CLI, Gemini CLI, Aider, Cline, Kilo Code, goose, OpenHands, Crush, T3 Code, Roo Code (archived), Continue (archived), OpenClaw. - Runtimes: llama.cpp, Ollama, vLLM, SGLang, MLX. - Frameworks: LangGraph, LlamaIndex, DSPy, Pydantic AI, CrewAI, AutoGen, Microsoft Agent Framework, AG2, OpenAI Agents SDK, Claude Agent SDK, Google ADK, smolagents, Mastra. - MCP and skills: MCP reference servers, MCP Registry, GitHub MCP server, Playwright MCP, Chrome DevTools MCP, anthropics/skills, obra/superpowers, agentskills.io. - Orchestration and evals: Gas Town, Beads, SWE-bench, Inspect, promptfoo. - Anthropic, Building effective agents (Dec 2024).

Primary sources: policies and maintainers - Daniel Stenberg, The end of the curl bug bounty (Jan 26, 2026). - Gentoo AI policy; QEMU code provenance policy; LLVM AI tool use policy; Linux kernel guidance for AI coding assistants; Ghostty AI usage policy.

Commentary and reporting - OpenClaw on Wikipedia, for the naming timeline and later history. - BleepingComputer, Malicious Moltbot skills used to push password-stealing malware (2026). - The Register, Curl shutters bug bounty program to remove incentive for submitting AI slop (Jan 2026).

Terms introduced¶

Open-source software: software whose source code is published under a license allowing use, modification and redistribution.
Open-weight model: a model whose trained weights are published (see module 04); distinct from open-source software.
MIT / Apache-2.0: permissive open-source licenses; Apache-2.0 adds an explicit patent grant.
FSL (Functional Source License): a source-available license that forbids competing commercial use and converts to a permissive license after two years.
Source-available: code you can read but not freely reuse, unlike open source.
Inference runtime: software that loads model weights and generates output (llama.cpp, Ollama, vLLM, SGLang, MLX).
GGUF: the quantized model file format used by llama.cpp and tools built on it.
PagedAttention: vLLM's technique for managing attention memory in pages to serve more requests at once.
Agent framework: a library of building blocks (model clients, tools, state, tracing, multi-agent coordination) for building agents.
Agent SDK: a vendor's agent harness packaged as a library, such as the Claude Agent SDK or OpenAI Agents SDK.
Repository map: a compact summary of a codebase's files and symbols given to an agent, popularized by Aider.
Personal agent: an agent that acts across a person's own accounts and devices, often through messaging apps.
Skill registry: a public catalog of installable agent skills, which is a software supply chain.
Orchestrator: software that coordinates many agents, such as Gas Town.
Beads: a Dolt-backed graph issue tracker that agents use as shared, structured memory.
AI slop: low-effort, unverified AI-generated content, such as fake bug reports or careless pull requests.
Extractive contribution: in LLVM's policy, a contribution that costs maintainers more to review than it gives the project.
Assisted-by: trailer: a commit-message line disclosing that a tool helped produce the change.
Signed-off-by / DCO: a commit tag by which a human certifies the Developer Certificate of Origin; the Linux kernel forbids AI agents from adding it.
Vouching: Ghostty's system in which a maintainer approves a first-time contributor before their PRs are accepted.