A Verified Open-Source Stack for AI Agents
A practical, checked list — the positive companion piece to Physics First, Verification Always
A popular framing has been going around describing AI agent architecture as four layers — Skills, MCP, Subagents, and Hooks — with a proprietary tool suggested for each. As someone who prefers open-source and independent tooling where it exists, I wanted to know what a genuinely open-source equivalent would actually look like.
So rather than take a generated list at face value, I checked each suggestion against its actual repository, paper, or project page. Most of it held up. A little of it didn't, and one gap turned out to be more interesting than a simple substitute would have been. Here's the result.
The process itself is worth being honest about. I first asked an LLM-based search tool for an open-source equivalent of that four-layer framing, and got back a nicely organized, confident-sounding answer. It turned out not to be fully accurate. Running the same question through a second LLM-based check, with an actual emphasis on verification this time, produced a much more thorough, checkable version — and surfaced some genuinely interesting details along the way, including at least one case where a real project existed under the same name but with different specifics than first claimed.
The main lesson isn't "don't trust these tools" — it's the opposite, really: used carefully, this kind of search is a genuinely remarkable way to get fast, specific, and ultimately reliable information, far beyond what manually digging through GitHub myself would have found in the same time. But "used carefully" is doing real work in that sentence, and it's not something I always manage well — I tend to react to things emotionally before I've properly checked them, which is exactly the habit I'm trying to get better at.
Skills — packaging know-how as installable capability
Skillware treats agent skills the way a package manager treats software: installable, versioned units of executable logic, instructions, and safety boundaries, rather than something re-written into every project's system prompt from scratch. Real, actively maintained, and does what it says.
One piece I couldn't verify: a tool that routes only the relevant subset of a large skill library into context for a given task, using BM25-style relevance ranking rather than loading everything. The specific tool named for this didn't check out as a real, independent project. The underlying idea is real, though — Postgres has genuine BM25 full-text search available via ParadeDB, and there's at least one published cross-encoder model (SR-Rank) built specifically for reranking candidate skills against a task query. No single packaged tool yet combines these into what was described — but the pieces to build one already exist, openly, if anyone wants to.
MCP — the connection layer
Three real, independently verifiable projects here, each doing a distinct job:
- zeromcp — a genuinely minimal, zero-dependency MCP server in pure Python. Under 1,000 lines, HTTP/SSE and stdio transports, nothing hidden.
- InfraMCP — a family of MCP servers for infrastructure automation (SSH, Windows/WinRM, VMware vSphere, Jira/Confluence, GitLab, and more), letting an agent interact with real infrastructure through one consistent protocol.
- MCPTransports — adds Unix Domain Socket transport for MCP, for fast, secure same-machine communication where a full network transport is unnecessary overhead.
Subagents — delegation and specialized execution
- CrewAI — the most established name here by a wide margin: role-based multi-agent orchestration, open-source core with an optional enterprise layer, under active development since December 2023.
- AgentFactory — a genuinely research-backed approach, not just a GitHub project: a published paper (Peking University / BAAI) describing a self-evolving framework that saves successful task solutions as reusable, executable subagent code rather than text, refining them as more tasks are encountered.
- Conductor — worth a direct correction here, since the description going around for this one didn't match reality: it's not a Java framework with "explicit/implicit" agent types. The real Conductor (Microsoft, MIT-licensed) is a YAML-defined workflow CLI with fully deterministic routing — no LLM in the orchestration loop itself, Jinja2 templates and expression evaluation deciding what runs next. That's arguably a more interesting design than what was originally claimed: predictable, version-controllable workflows instead of an LLM re-deciding the plan on every run.
Hooks — deterministic control and automation
The tool named for this layer didn't turn up any independent trace at all — no repository, no package, no mention anywhere I could find. Two real alternatives cover the same ground properly:
- agenthooks — an open format for event-driven agent hooks: folders containing executable scripts plus metadata, triggered on events like
pre-tool-call, matched against specific tools or patterns (e.g. blocking a dangerous shell command before it runs). - goose — Block's open-source AI agent, with a real, documented hooks system (
PreToolUse,PostToolUse,SessionStart, and more) via the Open Plugins specification.
Putting it together
A genuinely open-source stack, then: Skillware for packaging skills, one of the three real MCP projects above for external connections, CrewAI or AgentFactory for delegation, agenthooks or goose for control and automation — all real, all independently checkable, all without a subscription.
One honest note
Everything above was checked against its actual source before being included here — not because open-source claims are especially prone to being wrong, but because any list like this, human-written or otherwise, is worth checking before you build on it. Small projects change fast, maintainers move on, READMEs describe aspirations as much as reality sometimes. The links above are a good starting point, not a substitute for looking at a repository yourself before depending on it — which, in fairness, is exactly what putting this list together required in the first place.
This piece itself was drafted with AI assistance, then checked and edited by hand — the same position it argues for: a tool for narrowing and drafting, not a source of unverified claims.