Multi-Agent Frameworks

A hands-on repo that teaches Claude Agent SDK by revealing tools, subagents, and memory one layer at a time, so readers learn orchestration before syntax.

A Python framework for testing market design, bidding strategy, and grid behavior with agent-based models, deep reinforcement learning, and coupled market clearing.

A FastAPI and vanilla-JS operating environment for multi-agent work, persistent memory, cron automation, and task scoring that improves how agents behave over time.

A deep dive into how a Seville-based workflow stack routes conversations, checks inventory, parses dates, and hands off to humans without relying on one giant prompt.

Inside the repo that replaces "generate more tests" with a stricter idea: load only the right knowledge, follow only the current step, and decide what not to test.

A Rust-based runtime for long-running AI work, with persistent state, self-healing loops, and multi-agent governance built into the core.

A deep look at the Elixir, TypeScript, and browser runtime stack behind an open-source system built for autonomous labor, not chat.

Inside the Harvard-built agent that plans experiments, checks biological context, writes code, runs it, and cross-checks the literature before it speaks.

How the Whiteport Design Studio expansion transforms structured Markdown into a high-fidelity orchestration layer for AI agents.

A sample repo that moves from WebSocket bots to interactive cards to MCP agents, and shows why the connection model matters as much as the code.

A Dolt-powered system for claims, reviews, and reputation that treats rows like pull requests and communities like synchronized branches.

A curated map of the standards, tools, and protocols that turn onchain agents from chatty scripts into economic actors.

How a Claude Code skill uses pseudo-Lisp and ASCII matrices to force LLMs out of polite consensus and into rigorous philosophical debate.

Stop wasting billions of parameters on basic intent. How a multi-head classifier uses interaction history and calibrated confidence to gatekeep expensive model calls.

A 7-phase orchestration system that turns research into a stateful workflow, grades evidence before synthesis, and keeps queries anchored to the current year.

HKUDS splits planning, execution, and review into separate roles, then uses a shared board to keep the whole system legible, recoverable, and easier to debug.

A Rust desktop app that treats parallel coding agents as isolated workspaces with attachable sessions, not as more chat windows.

It turns missing story inputs into a first pass, then keeps the draft moving.

How a pure-Rust runtime turns fragile LLM scripts into portable, stateful, and self-extending infrastructure.

Sakana AI’s framework turns brittle agent-based modeling into repeatable experiments, with tools, memory, and a second parsing pass when models return messy output.

Sakana AI's open-source pipeline turns phonology, grammar, lexicon, and orthography into a reproducible language build, not a one-shot prompt.

How a pedagogical project rooted in manual Python scripts evolved into a LangGraph-powered simulated study group.

A deep look at the pack architecture, the filesystem-backed state model, and the surprisingly durable way this project turns Discord threads, DMs, and modals into workflow infrastructure.

How a lightweight orchestration layer turns a synchronous terminal assistant into a non-blocking engineering team.

A deep dive into the prompt architecture, parallel scoring, live web research, and PDF generation that transform Claude Code into an on-demand reputation analyst.

Moving beyond the mega-prompt to a 14-agent hierarchical orchestration framework for SaaS growth.

Google Research breaks scientific visualization into retrieval, planning, styling, generation, and critique, then loops back until the chart earns publication-grade confidence.

Inside a cross-lab Mixture-of-Agents harness that turns Codex, Gemini, and Claude into parallel proposers, broadcast refiners, and a final aggregator for repo-grounded implementation planning.

A five-agent trading workflow that pulls live web data, assigns specialized roles, and turns prompt files into a repeatable analyst pipeline.

A TypeScript framework for autonomous workers, with a six-stage execution pipeline, multi-channel control, and Solana-aware safety rails.

A Dolt-backed Claude Code marketplace where tasks, trust, and agent identity are modeled in SQL, and the app is mostly a skill file that teaches Claude how to work.

Inside a Holochain system where assets do not just exist. They carry lifecycle, rules, receipts, and permissions with them, so communities can coordinate shared resources without a central platform.

How a strictly validated metadata contract transforms fuzzy AI agents into predictable enterprise collaborators.

Moving beyond the chatbox to orchestrate a parallelized, self-healing digital workforce on your local filesystem.

It runs on Bash, Markdown, Cron, Telegram, and Playwright. That simplicity is the point: BrandCrew turns a content workflow into a readable, editable, human-in-the-loop machine.

How an opinionated TypeScript monorepo uses Edge functions, Redis streams, and free-tier model routing to bypass the LLM API tax.

A multi-agent due diligence system that goes beyond RAG, combining web research, browser automation, and asynchronous outreach into one persistent workflow.

A machine-readable context pack, curl-based onboarding, and ERC-8004 identity turn a hackathon into a blueprint for agents that can pay, prove, and cooperate on-chain.

How Langflow's minimalist Python bridge solves the asynchronous routing problem of connecting local desktop clients to cloud-hosted Model Context Protocol servers.

How a tripartite agent architecture abstracts away the danger of decentralized finance using a built-in constitutional safety net.

A durable execution layer for GitHub Copilot SDK agents, built to survive crashes, sleep through long waits, and resume exactly where they left off.

A TypeScript bridge for local agents that streams output to the browser, auto-hosts on demand, and treats abort, undo, and redo as core behavior.

How BMAD-Bundles uses XML cartridges to turn raw LLMs into structured agile squads.

How an ASGI transport layer and a clever state-machine middleware are turning monolithic AI scripts into truly non-blocking, background microservices.

How an adversarial AI swarm and strict tool constraints are automating the grueling janitor work of open-source repository maintenance.

A protocol-level experiment in turning flat primitive lists into navigable groups, so clients can surface less noise, spend fewer tokens, and help models find the right capability faster.

A close look at the repo that gives agents identities, wallets, friends, and, most unusually, a heartbeat that tells them what to do next.