Multi-Agent Frameworks

A Claude Code dispatcher, specialized agents, and filesystem state turn an Obsidian vault into a self-managing personal operations layer.

A deep dive into CLM’s split state-action architecture, why its cacheable inference loop matters, and how it rethinks System One for tool use, verification, and real-time decisions.

A cross-platform team workspace that turns AI agents into persistent teammates, splits the brain from the platform, and uses local daemons, cloud pods, and coordination rules to keep everyone in sync.

A lean Python wrapper on top of a patched Firefox engine, `dots` treats web automation as an identity problem. Its real trick is making one seed behave like one consistent human across fingerprint, input, and session state.

A Remotion-based agent pipeline that writes the script, times the narration, generates the visuals in code, and checks the result like software, not like a film edit.

When multiple autonomous agents work on the same codebase, they overwrite each other's work. Here is how one developer used Git hooks, SQLite, and an email metaphor to force them to collaborate.

A deep dive into how `eve` uses directories, tools, channels, approvals, schedules, and sandboxes to turn agent behavior into something you can ship and operate.

How a centralized GitHub Action and plain-English prompts created a zero-config, API-free content pipeline for local AI agents.

OpenClaw’s Lark plugin turns a chat window into a workspace operator, with approvals, streaming cards, and secure token storage.

A model-agnostic scientific IDE that reads papers, loads domain skills, runs experiments, and writes the report without handing your data to a vendor.

How a5c-ai uses event-sourcing and "Quality Convergence" to turn flaky LLM coding into a deterministic engineering pipeline.

A state-aware routing layer for A2A networks that weighs progress, permissions, trust, and handoff friction before it commits a task to SELF, COLLABORATE, or HANDOFF.

Google Cloud Platform’s experimental orchestration testbed turns multi-agent coding into an isolation problem. `git worktree`, `tmux`, and runtime boundaries do the coordination prompts cannot.

Forsy-AI’s ecosystem treats every task run as a lesson: trace it, critique it, revise it, and feed the result back into a shared memory for future agents.

From one seed document, it builds grounded agents, runs them across social platforms and prediction markets, and lets you inspect the timeline when the world changes.

A document goes in. Hundreds of agents, social platforms, and a prediction market come alive. Then the human operator can fork the timeline and test what happens when the story changes.

A dual-agent system turns visual matching into a loop of rendering, verification, and revision, making image reconstruction editable instead of opaque.

By turning isolated LLM sessions into a real-time mesh network, claude-peers-mcp creates a collaborative swarm on a single machine.

A bilingual guide to building feedback loops for agents, and why verification, not prompting, is becoming the real architecture layer.

A TypeScript harness for planning, sub-agents, and persistent state that makes long-running AI workflows feel like real software, not prompt glue.

How 3,500 lines of pure Python created an autonomous agent that writes its own tools and manages its own uptime.

How math-inc is using multi-agent orchestration to bridge the gap between LLM intuition and the absolute rigor of Lean 4.

A deep dive into the Qwen project that turns environment dynamics into the product, using world modeling, robust parsing, and judge-based evaluation to train and test agents without touching real systems.

Instead of rethinking every screen with a vision model, PhoneCLI maps mobile navigation once, replays it as deterministic commands, and falls back to a model only when the UI is genuinely unfamiliar.

A Go SDK for multi-agent coding workflows that makes agent state durable, runtime visible, and reconciliation the core primitive.

How a repo-local brain, a work queue in plain text, and Git worktrees turn coding agents into something closer to an actual engineering system.

A no-daemon messaging layer that lets local AI agents talk, watch, and coordinate through one file, with locks and prompts designed for models, not humans.

A deterministic conlang system turns one numeric seed into grammar, vocabulary, and encoded agent-to-agent communication, revealing how linguistic design, obfuscation, and red-teaming collapse into the same machine.

A deep dive into the framework that separates literature memory from experiment history, then uses that split to evolve architectures, data pipelines, and learning algorithms through repeated trials.

It starts as a standard OpenAI-compatible client, then unlocks memory, terminal, skills, and sessions when the Hermes gateway is present.

Eleven autonomous personas watch live football, commit markets before the action unfolds, and settle winners through a hook-driven prediction protocol.

How a multi-agent "inner loop" transforms LLM hallucinations into verifiable mathematical conjectures.

HKUDS built a universal tool-use layer that narrows a noisy tool universe to the few calls that actually matter, then routes work through GUI, shell, MCP, or a sandboxed server.

The official Lark bridge does more than expose office APIs. It helps an agent find the right endpoint, choose the right token, and carry out real work across chat, docs, calendar, and spreadsheets.

A local-first co-scientist that routes tasks through an orchestrator, hands execution to sandboxed experts, and keeps scientific workflows controllable, extensible, and model-agnostic.

Microsoft Research’s framework turns a vague software request into a dependency-aware repository blueprint, then generates files in the order the structure demands.

How AgentFlow turns brittle LLM scripts into programmable, self-correcting graphs that spawn their own cloud infrastructure.

A research framework that separates what a figure should say from how it should look, then loops in retrieval, style guidance, and critique until the result fits academic standards.

Inside Trampoline AI’s recursive language model runtime, the LLM stops being a tool caller and starts acting like a program that can recurse, parallelize, and keep state without drowning in context.

How EveryInc turned Claude Code into a persistent knowledge engine that remembers past mistakes, parallelizes research, and refuses to guess.

How HKUDS and Alibaba are moving beyond "Deep Research" to automate the "Aha!" moment of scientific discovery through decoupled reinforcement learning.

How a 'Workflow-as-Code' framework turns unpredictable LLMs into disciplined, multi-agent game studios.

An open-source messenger built for AI agents, human teams, and the messy middle between them.

A deep dive into the repo that turns prospect research, lead qualification, outreach, meeting prep, and PDF reporting into a routed system of markdown skills, Python scripts, and parallel agents.

A cross-framework masterclass in reflection, planning, skill loading, and memory, showing how to build AI systems that behave like software, not prompts.

A look at the architecture, prompt compression, and routing tricks that make sub-10B models viable for real agent workflows.

How Block’s flock of geese coordinates research, writing, review, and handoff with a filesystem message bus, a context-saving orchestrator, and a dashboard that makes agent work visible.

By replacing agentic loops with typed combinators, λ-RLM turns long-context reasoning into a deterministic tree of small, bounded model calls.