Multi-Agent Frameworks

Inside the Runnable kernel that turns prompts, models, retries, and traces into one composable system.

How the standard library for AI agents survived its monolithic origins by abandoning simple chains for stateful, observable graphs.

A multi-agent framework that turns research, debate, risk control, and memory into a synthetic hedge-fund workflow.

A multi-agent graph engine that turns source trees, docs, and business rules into guided tours, semantic links, and living knowledge maps.

A universal agent library for Claude Code, Cursor, Aider, Windsurf, and more, built to package expertise, enforce trade-offs, and ship personality as configuration.

Inside karpathy/autoresearch, where the human writes the Markdown protocol and the AI writes the PyTorch.

While most AI agents are built to execute tasks, MiroFish uses GraphRAG and multi-agent swarms to simulate how thousands of humans will react to new information.

A deep look at the open-source system that turns coding assistants into directors, routes work across multiple model providers, and uses code to do the parts AI video tools still cannot control.

An open-source control plane that turns prompts into org charts, budgets, governance, and auditable workstreams.

A look inside the architecture that separates market storytelling, hard valuation math, and risk control into one workflow that behaves more like a hedge fund than a chatbot.

Why the next phase of AI development looks less like a chat box and more like a high-stakes board meeting.

A self-hosted agent runtime with multi-channel reach, MCP-native tools, and a Dream memory system that turns long-term context into readable files instead of opaque state.

Moving beyond linear pipelines, this framework-less system reconstructs public opinion by forcing specialized AI agents to challenge each other's biases.

An open-source tutoring system that can spin up specialist agents, preserve a clean student transcript, and build a lasting memory of what each learner actually knows.

HKUDS built a multi-agent finance workspace that turns natural language into backtests, market-specific code, and cross-platform exports for global trading workflows.

A role pack here is just markdown, JSON, and MCP wiring. The twist is a meta-plugin that can customize and scaffold the rest, turning Claude into a more company-shaped coworker.

A deep dive into the agentic skill router, ATS-safe PDF pipeline, and human-in-the-loop architecture that turns flat files into a candidate’s command center.

Moving beyond simple prompts to a world of Raft consensus, WASM kernels, and algorithmic agent agreement.

How `vercel/ai` turns fragmented model APIs, tool calls, and reasoning controls into one continuous loop that feels simple on the surface and deeply orchestrated underneath.

HKUDS turns trading into a social protocol. Agents read `SKILL.md`, register themselves, publish signals, debate strategy, and execute across stocks, crypto, and Polymarket.

LangChain’s opinionated stack for planning, files, shell access, sub-agents, and human approval. It is less a chatbot framework than a controlled workspace for long-running work.

A Python-first framework that turns handoffs, sessions, guardrails, tracing, and realtime voice into one coherent agent loop.

Moving beyond the monolithic prompt to a world of distributed, recursive, and multi-language agent hierarchies.

A local-first agent platform that turns files, terminals, Slack, Jira, and approvals into one supervised workflow.

A Go orchestration stack where tasks live in Beads, agents run in sandboxes, and least-privilege proxies keep multi-agent coding from collapsing into context loss.

A deep dive into the control plane behind tool use, memory, permissions, and multi-agent coordination.

How openai/symphony leverages the Erlang VM to turn fragile AI coding agents into reliable, background-running employees.

While the industry chases complex microservice stacks, one project is quietly building a unified, "all-in-one" operating system for semantic search and autonomous agents.

A deep dive into the LangGraph loop, reroute logic, and evidence validation system that turns outage triage into a proof-driven workflow.

A minimalist LLM orchestration engine, a string-based routing model, and a surprising second act: using Cursor rules to help AI write the workflows that AI will run.

A deep look at how `yc-software/qm` turns isolated agent sandboxes, scoped identity, and Slack-native collaboration into shared company infrastructure.

A minimalist graph engine, a state machine with loops, and a documentation layer that turns Cursor into a collaborator instead of a passenger.

The open-source AI coworker stores context in a local, editable vault, then uses permissions, skills, and MCP to act on it.

A slim OpenCode plugin that turns LLMs into a staffed team. An orchestrator delegates, specialists execute, and a council argues before the human ever sees the result.

A TypeScript-native orchestration engine that plans work at runtime, pauses for human approval on consequential actions, and keeps the whole run auditable from start to finish.

A deep dive into a durable, evidence-first customer system that flips the usual CRM model. Humans define intent. Agents gather proof. The database just records what survived scrutiny.

A runtime injector and reasoning-mode router that patches agent behavior without restart, then keeps models on task with near-field guidance and self-checking control loops.

How a library of 136 configuration files turns OpenAI Codex from an unpredictable chat interface into a tightly constrained, multi-agent engineering team.

OpenBot gives agents their own browser, files, and tools, but the real innovation is stricter than autonomy. It uses accessibility-tree control, path confinement, policy checks, audit logs, and human takeover to make agent behavior legible and containable.

How a research lab bypassed complex API orchestration by using tmux, git worktrees, and filesystem locks to manage autonomous AI agents.

A look at the GEPA loop, the Skill-as-Module abstraction, and the guardrails that keep self-improvement from turning into prompt bloat.

How "Micro-Servers" at the edge are solving the AI amnesia problem by merging compute and memory into a single persistent entity.

How a folder of plain Markdown files and adversarial LLM psychology turned Claude Code into an autonomous ML researcher.

A self-hostable CopilotKit template for persistent AI coworkers, where conversations become documents, tools live behind permissions, and every agent can carry state across web, voice, and Slack.

A parallel divergence layer for Claude-powered agents that fans out isolated thoughts, scores for traps, clusters by angle, and deepens only the survivors.

A meta-agent uses benchmark scores, a fixed adapter boundary, and a simplicity rule to evolve prompts, tools, and orchestration without human micromanagement.

A TypeScript meta-harness that treats LLMs as interchangeable brains, routes them through a mission loop, and insists on evidence instead of vibes.

A meta-harness that sits above Claude Code, Codex, and custom agents, combining sandboxing, live session sync, and cross-tool orchestration into one workspace.