I Read Twelve Agent Codebases in a Weekend. The Dead Ones Taught Me the Most.

Eleven days ago, on 13 August 2026, the maintainers of Flowise archived their repository. Fifty-five thousand GitHub stars, twenty-five thousand forks, one of the defining projects of the 2023 low-code AI wave — frozen, read-only, npm packages deprecated. Their farewell note was unusually honest for this industry: as models got better at reasoning, developers stopped wiring nodes on a canvas and started handing whole tasks to coding agents, and the visual workflow approach simply hit its ceiling.

So I spent the weekend actually reading agent codebases rather than skimming their READMEs: twelve repositories, from a 43-star slide-generation demo to AutoGPT’s 186,000-star monorepo. My day job is architecting the governed context that grounds AI agents in enterprise data, so I have a professional obligation to know which of these ideas are real and which are stars-driven theater. The frameworks disagree loudly about everything visible — language, licensing, philosophy — and agree almost completely about the things that matter. The dead ones taught me the most.

The graveyard votes first

Two of the twelve are cautionary tales, and they fail in opposite directions.

AutoGPT’s original 2023 agent — the viral loop that took a goal, self-prompted, and ran until it succeeded or your API budget didn’t — now lives in a folder literally named classic/, kept around for benchmarking. The team’s actual product today is the AutoGPT Platform: agents composed as explicit graphs of typed blocks, with integrations, schedules, and a marketplace. Read that pivot carefully, because it is a confession. The most-starred agent project on GitHub concluded that unbounded autonomy was the bug, not the feature, and rebuilt itself around the opposite premise: reliability comes from structure you can inspect.

Flowise failed from the other side. It had all the structure — every chain and agent a visual node graph — and discovered that structure without capability is just friction. When a coding agent can produce and revise the whole pipeline in conversation, a drag-and-drop canvas stops being an abstraction and starts being a tax. The 2023 thesis was that visual builders would democratize LLM apps. The 2026 result is that the canvas was a transitional interface, useful precisely as long as the models underneath it were weak.

Put those two failures together and you get the actual design space: too little structure kills you, and structure in the wrong layer kills you too. The structure has to live in the contracts — what an agent is allowed to do, what it must produce, when a human signs off — not in boxes and arrows.

The best documentation was never meant to be published

The two strangest repositories on my list are archives of other people’s system prompts. x1xhlol/system-prompts-and-models-of-ai-tools collects the extracted internals of commercial coding agents — Cursor, Devin, v0, Manus — including their tool schemas, and has accumulated roughly 143,000 stars. CL4R1T4S, maintained by the jailbreaker known as Pliny the Liberator, does the same for the frontier chat assistants, framed explicitly as a transparency project. The two were created a day apart in March 2025, which tells you something about when the industry realized the prompts themselves were the product.

I have real reservations about republishing commercial prompt text, and I would not paste a line of it into a production system. As engineering evidence, though, these archives are unmatched, because they show what the best-funded teams in the world actually ship rather than what they blog about. So I read them alongside the frameworks, where a leaked prompt and an open-source framework kept arriving at the same rule from opposite directions. Those agreements sort themselves by where in an agent’s life they bite.

Before the work is dispatched

Four production frameworks, written independently in two languages on three continents, converge first on a rule about what has to exist before an agent starts: the output is declared in advance.

CrewAI — MIT-licensed, 57,000 stars, and pointedly built without LangChain — will not let you define a task without an expected_output field. The validation fails without it. That is a small, deeply opinionated decision: the framework refuses to let you dispatch work you cannot evaluate. Anyone who has managed people recognizes the principle; it is remarkable how long it took agent frameworks to encode it.

GenSlide, a 43-star LangGraph demo that turns documents into PowerPoint, gets two things right that products a thousand times its size get wrong, and the first is that it plans the outline before writing any slide. The commercial prompts obey the same rule: planning, writing, and dispatching are separate modes with separate instructions, never one mega-prompt. Three teams with nothing in common reached the same conclusion — the plan is an artifact produced before the work rather than something the model improvises on the way through.

The other pre-dispatch decision is how much discretion to hand over, and here the survivors agree that autonomy is a parameter, not a product line. CrewAI’s split between Crews (agents that decide how) and Flows (developers decide exactly what runs when) is the cleanest articulation, but ZeroClaw’s risk profiles and Dify’s workflow engine express the same idea: one execution engine, with the degree of agent discretion dialed per task. Nobody serious ships a separate “autonomous mode” codebase anymore. The graveyard explains why.

When a human has to be involved

Human approval is a paused run, not a pop-up. The answer is unanimous, and it is where these projects most obviously write from production scars.

Agno (formerly phidata, rebranded in January 2025) stores sessions, traces, and pending approvals as rows in your own database, served through its FastAPI-based AgentOS runtime. ZeroClaw — a Rust runtime that ships as a single static binary and claims under five megabytes of memory — defaults to a “supervised” mode where medium-risk operations wait for a human and high-risk operations are refused outright, with cryptographic receipts on every tool call. CrewAI pauses a task on human_input=True. Different stacks, same architecture: the human checkpoint is durable state with an identity, something you can query, resume, or expire — not a modal dialog the agent hopes someone clicks.

The leaked prompts arrive at the same contract from the other side. Asking the user is implemented as an explicit tool, with a schema, so the model escalates instead of guessing. The framework makes the pause durable; the prompt makes the pause reachable. For anyone putting agents in front of enterprise customers, I would call that pair the single non-negotiable pattern of the twelve repositories.

What the run leaves behind

The last agreement is about output, and the small repositories argue it best. Every leaked prompt I read keeps the polished artifact the customer sees in a separate channel from the agent’s working notes and citations. None of that is published in any vendor’s documentation. All of it is essential. GenSlide’s other virtue shows what the separation buys you downstream: when a reviewer asks for changes, it edits only what the feedback names instead of regenerating the deck. Anyone who has watched an AI tool destroy twenty minutes of accumulated tweaks with a full regeneration understands why surgical revision is the feature. You cannot revise surgically unless the artifact and the reasoning behind it were separable to begin with.

Tencent’s WeKnora, open-sourced in July 2025, carries the same separation into the thing agents should produce from a pile of enterprise documents. Not chat answers — a wiki: interlinked Markdown pages the agents maintain autonomously, with the one feature that makes it viable, which is that human edits carry revision history, line-level diffs, and rollback, so an overnight agent run cannot silently trample what a person deliberately wrote. Knowledge as a versioned, co-edited artifact rather than a bag of retrieval chunks is, I suspect, where most enterprise RAG ends up.

Put it in files, version it, let a human diff it — the same instinct shows up in the smallest projects on the list. html-anything, an Apache-licensed local editor out of the OpenDesign team, inverts the usual SaaS architecture: it ships no API keys at all, instead detecting the coding-agent CLIs already authenticated on your machine and spawning them against a library of 75 skills — each skill just a folder with a SKILL.md and hard-coded design constraints (baseline grids, contrast minimums, a ban on placeholder text). Skills as plain files, discovered by convention, versioned in git: I think that idea outlives the editor. And prompts.chat — which most people still know by its old name, awesome-chatgpt-prompts — made the most elegant licensing decision of the twelve: the platform code is MIT, but the prompt corpus itself is CC0, public domain, and remains plain CSV and Markdown in the repository even as the product grew into a self-hostable platform with an MCP server. The data outlives the app. That is how you steward a commons.

The business model moved into the license

Read the licenses, because the business model now lives there. Dify’s license is Apache 2.0 until you read the two added conditions: no multi-tenant operation without written authorization, and no removing the Dify logo from the console. AutoGPT’s monorepo is split — the historic agent is MIT, the platform is Polyform Shield, which permits self-hosting but forbids offering it as a competing service. This is the quiet standardization of 2025–26 open source: the code is open, the SaaS business is fenced. I don’t say that as criticism — it is a rational response to the cloud-provider strip-mining of the last decade — but if you are building on any of these, the license file is now architecture documentation.

The twelve, in one line each

Steal contracts, not runtimes

That is the whole weekend compressed into one instruction. Every one of these projects would love to be your platform, and none of them should be — good software, all of it, but the runtime is the part that ages. Flowise’s canvas is already gone; AutoGPT’s loop is a museum piece; today’s frameworks will be refactored beyond recognition within two years. What persists are the agreements, and those five agreements appeared independently in Python frameworks, Rust binaries, Tencent’s Go services, and the leaked prompts of companies that have never spoken to each other.

When that many teams converge under competitive pressure, the convergence is the shape of the problem showing through — a far better guide to building agent systems than any single framework on this list.

References

1. GitHub. Repository details — stars, licenses, dates — verified as of 24 August 2026.