ThibautMelen/agentic-ai-systems: Agentic Patterns as CI-Checked Files
Agentic AI explained with chickens 🐔 every pattern a runnable, CI-checked file.
At a glance
- What is it?
- A documentation repository that turns agentic AI patterns into runnable, CI-checked files, with chickens as the running metaphor. It is a teaching and reference resource, not a framework you import.
- Who is it for?
- Adopt this repository if you are designing an agentic system on top of Claude Code and want a pattern vocabulary with runnable examples before you commit to an architecture. Skip it if you need a library to import, a hosted runtime, or a benchmark of pattern performance, because the repository ships documentation and checkable files rather than an engine.
- Can I use it commercially?
- Yes. MIT is a permissive licence: you can use, modify and sell software built on it, as long as you keep its copyright and licence notices.
- Is it still maintained?
- Yes. The repository last received commits 67 days ago.
- What is it written in?
- GitHub does not report a main language for this repository.
Answers come from the project's GitHub data, last synced on September 15, 2026, and from our analysis. They are not legal advice.
DEEP OPEN-SOURCE ANALYSIS
The gap this repository fills: naming agentic patterns before you build
Most teams building with LLMs reach the same fork in the road without a shared vocabulary. One engineer writes a single prompt with tools attached. Another writes a chain of prompts where each output feeds the next. A third spawns a coordinator that dispatches to specialists. All three call the result an agent, and none of them can compare designs because there is no common name for what they built.
ThibautMelen/agentic-ai-systems attacks that naming problem directly. The README organizes the field into Foundations, Workflows, Autonomous Agent, Implementation, and Patterns as Code, and it draws a hard line between the two orchestration families: workflows are described as predefined orchestration where code controls the flow, and the autonomous agent is described as dynamic autonomy where the LLM controls the flow. That distinction is the repository's central claim, and it is the one worth stealing even if you never open another file.
The audience is narrow and specific. The README points at Claude Code, with implementation components mapped to .claude/agents/*.md, .claude/commands/*.md, .claude/skills/*/SKILL.md and .claude/settings.json. If you are not working in that ecosystem, the pattern taxonomy still reads, but the implementation chapter will not match your tooling. The chicken metaphor is the delivery mechanism, not the content: a hen with her chicks stands in for a main agent spawning subagents. It lowers the intimidation factor of a topic that is otherwise buried in vendor blog posts.
How the pattern taxonomy is structured, from baseline to autonomous agent
The workflows directory is numbered, which makes the progression explicit. 00-baseline covers a simple one-step task. 01-prompt-chaining covers sequential steps. 02-routing covers classify-and-dispatch. 03-parallelization covers independent tasks. 04-orchestrator-workers covers expert delegation. 05-evaluator-optimizer covers quality iteration. Each entry carries a use-when condition in the navigation table, so the repository is effectively a decision table with prose attached.
A Mermaid flowchart in the README encodes the same logic as a traversal. It asks whether the task is destructive, then whether it is complex, then whether the steps are predictable, then whether specialists are needed. Destructive tasks route to a Wizard node, which is the only branch that is not a pattern file. That single question is the most opinionated thing in the repository: it treats destructive operations as a separate class that should not be handled by a general orchestration pattern at all.
The agents directory holds the autonomous branch, plus a multi-window variant for cross-session state. The implementation directory is organized by Claude Code component rather than by pattern, which is a deliberate split: patterns describe what the system does, components describe where the file lives. The patterns-as-code directory is the newest layer, and the README claims every pattern is a runnable file checked in CI on every push with no API key needed. That claim is the one to verify against .github/workflows/check.yml before you quote it internally, because the README does not enumerate what the checks assert.
Installing nothing: cloning the repository and reading the first pattern
This is a documentation repository, so there is no package to install and no runtime to start. The README does not give an install command, a package name, or a version pin, because there is nothing to install. What you do instead is clone the repository and read it locally, which matters if you want to follow the relative links between pattern files.
Start with the clone, then open the decision guide that the README lists under Guides.
git clone https://github.com/ThibautMelen/agentic-ai-systems.git
cd agentic-ai-systems
cat guides/README.mdThe selection guide is the entry point the README recommends for choosing a pattern. Read it alongside the Quick Decision table in the README, which maps situations to patterns: a simple one-step task to the baseline, sequential work to chaining, and so on.
From there, the patterns-as-code directory is where the runnable files live. The README states these are checked in CI without an API key, which is the property that makes them safe to run on a laptop or in a pull request. Check the workflow file to see what the checks do before assuming a green badge means your own adaptation is correct.
ls patterns-as-code/
cat .github/workflows/check.ymlThe workflow file is the contract. If it only validates file structure and link integrity, a passing badge tells you the repository is internally consistent, not that the pattern produces good output. The README does not document what check.yml asserts, so read it yourself.
Where the chicken metaphor costs more than it pays
The metaphor is load-bearing in the README and in the navigation, and that is a real trade-off. A hen and chicks map cleanly onto a main agent spawning subagents, and the emoji make the directory tree scannable. But the metaphor does not extend to the harder patterns. There is no chicken for an evaluator-optimizer loop, no chicken for routing, and no chicken for the distinction between parallelization and orchestrator-workers. Those entries carry emoji as labels, not as explanations, so a reader who arrives expecting the metaphor to carry the concept will find it stops at the first fork.
The second cost is discoverability for search. The repository is titled with a chicken emoji and the README opens with a joke. Engineers searching for the pattern names will find the files, but anyone skimming a link preview gets the joke first and the content second. That is a presentation choice, and it is defensible for a teaching repository, but it is worth knowing before you paste the link into a design document that non-engineers will read.
The deeper limitation is scope. The README frames the whole field through Claude Code components and Anthropic research, and the implementation chapter only documents where things live inside .claude/. If your stack is a different agent framework, you can still use the workflow taxonomy, but you cannot use the implementation half at all. The repository does not claim to be framework-neutral, and it should not be read as one.
How this differs from a framework like LangGraph or CrewAI
The clearest way to place this repository is against a code framework. LangGraph and CrewAI are libraries: you install them, you import their primitives, and your orchestration runs inside their execution model. ThibautMelen/agentic-ai-systems is the opposite shape. It contains no importable package, no runtime, and no scheduler. Its patterns-as-code files are described as runnable and CI-checked, but they are demonstrations of a pattern, not a dependency you add to a service.
That difference determines when each is the right tool. If you need to ship a multi-step pipeline next week and you want retries, state persistence and a graph execution engine, a framework gives you those primitives directly. If you are still deciding whether your task needs a chain, a router, or an orchestrator, a framework will not answer that question for you; it will let you build any of the three with equal ease, which is exactly the problem. This repository is aimed at the second situation.
The comparison also runs the other direction. A framework's documentation tells you how to use its API. This repository tells you which pattern to reach for, and then shows the pattern as a file inside a specific tool's conventions. The cost is that the code you copy is tied to Claude Code paths such as .claude/agents/*.md and .claude/skills/*/SKILL.md. If you adopt a framework later, the taxonomy survives and the file layout does not.
Maintenance, the 2026 edition, and what the MIT licence covers
The repository is not archived, and the last push was on 2026-07-11. Release v2.0.0, dated 2026-07-10 and titled The 2026 Edition, is the most recent release listed. That is roughly two months before the date of this writing, so the project is recent but the release history does not establish a cadence you can plan around. There is one release in the list, and the README does not document a deprecation policy, a versioning scheme, or a rollback path for the pattern files.
The upgrade cost is low in the sense that there is nothing to upgrade: you clone or pull, and the content changes. The cost is higher in the sense that the repository is a moving target for a fast-moving field. The README itself flags foundations/what-changed-2026.md as a dated map covering context engineering, the multi-agent debate, and the AGENTS.md, SKILL.md and MCP stack. A dated map is honest about its own shelf life, and it also means the older pattern files may describe assumptions that the newer foundation document has since revised. Read both before treating a pattern as current advice.
The licence is MIT, per the LICENSE file and the badge in the README. MIT permits reuse, modification and redistribution with the copyright notice and permission notice retained. That is a permissive licence, and it does not by itself address the licences of any third-party material the repository links to, such as the Anthropic research the README cites. This is a description of the licence text, not legal advice; route anything commercial through your own counsel.
What the CI badge does and does not prove
The README carries a badge for the check workflow at .github/workflows/check.yml and states that every pattern is checked in CI on every push, with no API key needed. Those two facts together are the repository's strongest quality signal, because they mean the pattern files are at least structurally valid and executable without secrets.
They are also easy to over-read. A workflow that runs without an API key cannot be asserting anything about model output quality, because it has no model to call. It can assert that files parse, that links resolve, that expected paths exist, and that a local run completes. The README does not say which of those the checks cover. So the badge is evidence of internal consistency, not of correctness in your environment.
The practical consequence is that you should treat patterns-as-code as a starting template rather than a validated implementation. Copy the structure, run it against your own model and your own tools, and expect the failure modes that any single-run demonstration hides: a pattern that works on the example input may route incorrectly on ambiguous input, and the evaluator-optimizer loop in particular depends on a scoring step that the repository cannot validate without a model. The README does not document how to test that loop, and the search questions about testing agentic systems are not answered in the repository's own files.
Editorial conclusion
Adopt this repository if you are designing an agentic system on top of Claude Code and want a pattern vocabulary with runnable examples before you commit to an architecture. Skip it if you need a library to import, a hosted runtime, or a benchmark of pattern performance, because the repository ships documentation and checkable files rather than an engine. Before relying on it, read patterns-as-code/ and the check.yml workflow to confirm what the CI actually validates, then read foundations/what-changed-2026.md for the dated map of the field.
Frequently asked questions
What is an agentic AI in simple terms?
The repository draws the line at who controls the flow: in its workflows, code controls the flow, and in its autonomous agent pattern, the LLM controls the flow. A system is agentic in this framing when the model, not a fixed script, decides the next step.
What are some examples of agentic AI systems?
The repository lists them as patterns: prompt chaining, routing, parallelization, orchestrator-workers, and evaluator-optimizer under workflows, plus an autonomous agent and a multi-window variant under agents. Each has a use-when condition in the README navigation table.
What is an agentic system?
The README treats an agentic system as an LLM augmented with retrieval, tools and memory, organized either as a code-controlled workflow or an LLM-controlled autonomous agent. The foundations directory calls the augmented LLM the building block for everything else.
Is ChatGPT an agentic AI?
The repository does not discuss ChatGPT, so it cannot answer this. It describes agentic patterns in terms of Claude Code components such as .claude/agents/*.md and .claude/skills/*/SKILL.md.
How do I build agentic AI systems from scratch?
The repository's route is to pick a pattern from the selection guide, then copy the corresponding runnable file from patterns-as-code/. The README states those files are checked in CI on every push and need no API key.
How do I evaluate agentic AI systems?
The repository includes an evaluator-optimizer workflow for quality iteration, listed as pattern 05. The README does not document a general evaluation method beyond that pattern, and the CI check runs without an API key, so it cannot score model output.
Community notes