The solutions to these problems are scattered across research papers, framework docs, and production war stories. I collected and synthesized them into a set of "Agent Skills" - structured instructions that agents can load on demand when working on relevant tasks.
7 skills covering context engineering fundamentals:
- \\context-fundamentals\\: What context actually is (system prompts, tool definitions, retrieved docs, message history, tool outputs) and why context quality matters more than context length
- \\context-degradation\\: The failure modes - lost-in-middle (10-40% accuracy drop for middle content), context poisoning (hallucinations that compound), context distraction (irrelevant info consuming attention budget)
- \\multi-agent-patterns\\: Supervisor vs swarm vs hierarchical architectures, when to use each, and the "telephone game" problem where supervisors paraphrase sub-agent responses incorrectly
- \\memory-systems\\: Why vector stores lose relationship information, when to use knowledge graphs, and how temporal validity prevents outdated facts from conflicting with new ones
- \\tool-design\\: The consolidation principle (if a human can't say which tool to use, an agent can't either), error messages that enable recovery, response format options for token efficiency
- \\context-optimization\\: Compaction triggers, observation masking (tool outputs can be 80%+ of token usage), KV-cache optimization
- \\evaluation\\: Multi-dimensional rubrics instead of single metrics, LLM-as-judge for scale, human review for edge cases
It uses Anthropic's open Agent Skills format. Each skill is a folder with a SKILL.md file containing instructions. Progressive disclosure - agents load only skill names/descriptions at startup, full content loads when activated for relevant tasks.
Works with Claude Code, Cursor, or any agent that supports skills/custom instructions.
Would appreciate feedback, especially from anyone running multi-agent systems in production. What patterns are you seeing that aren't captured here?"},"story_title":{"matchLevel":"none","matchedWords":[],"value":"Agent Skills for Context Engineering"},"story_url":{"matchLevel":"none","matchedWords":[],"value":"https://github.com/muratcankoylan/Agent-Skills-for-Context-Engineering"}},"_tags":["comment","author_youraimarketer","story_46351787"],"author":"youraimarketer","comment_text":"I've been building multi-agent systems for the past year and kept running into the same problems: context windows filling up with tool outputs, agents losing track of information buried in the middle of long conversations, supervisors becoming bottlenecks as they accumulated state from all workers.
The solutions to these problems are scattered across research papers, framework docs, and production war stories. I collected and synthesized them into a set of "Agent Skills" - structured instructions that agents can load on demand when working on relevant tasks.
7 skills covering context engineering fundamentals:
- \\context-fundamentals\\: What context actually is (system prompts, tool definitions, retrieved docs, message history, tool outputs) and why context quality matters more than context length
- \\context-degradation\\: The failure modes - lost-in-middle (10-40% accuracy drop for middle content), context poisoning (hallucinations that compound), context distraction (irrelevant info consuming attention budget)
- \\multi-agent-patterns\\: Supervisor vs swarm vs hierarchical architectures, when to use each, and the "telephone game" problem where supervisors paraphrase sub-agent responses incorrectly
- \\memory-systems\\: Why vector stores lose relationship information, when to use knowledge graphs, and how temporal validity prevents outdated facts from conflicting with new ones
- \\tool-design\\: The consolidation principle (if a human can't say which tool to use, an agent can't either), error messages that enable recovery, response format options for token efficiency
- \\context-optimization\\: Compaction triggers, observation masking (tool outputs can be 80%+ of token usage), KV-cache optimization
- \\evaluation\\: Multi-dimensional rubrics instead of single metrics, LLM-as-judge for scale, human review for edge cases
It uses Anthropic's open Agent Skills format. Each skill is a folder with a SKILL.md file containing instructions. Progressive disclosure - agents load only skill names/descriptions at startup, full content loads when activated for relevant tasks.
Works with Claude Code, Cursor, or any agent that supports skills/custom instructions.
Would appreciate feedback, especially from anyone running multi-agent systems in production. What patterns are you seeing that aren't captured here?","created_at":"2025-12-22T06:08:56Z","created_at_i":1766383736,"objectID":"46351788","parent_id":46351787,"story_id":46351787,"story_title":"Agent Skills for Context Engineering","story_url":"https://github.com/muratcankoylan/Agent-Skills-for-Context-Engineering","updated_at":"2026-03-05T23:16:09Z"},{"_highlightResult":{"author":{"matchLevel":"none","matchedWords":[],"value":"NeuralOperator"},"story_text":{"fullyHighlighted":false,"matchLevel":"partial","matchedWords":["supervisor","architecture"],"value":"Hi HN, I built EvidionAI \u2014 an autonomous research pipeline where a Supervisor \norchestrates a loop of specialized agents to answer scientific questions \nend-to-end.
The workflow:\nSupervisor \u2192 Search (DDG + arXiv + Wikipedia) \u2192 Code (Python in sandboxed Docker) \n\u2192 Analysis \u2192 Skeptic \u2192 back to Supervisor if the conclusions don't hold up.
The focus is not just on execution, but on validation \u2014 the system actively \ntries to break its own conclusions via a skeptic loop.
Stack: LangGraph, LangChain, FastAPI, ChromaDB, SQLite (before that, there was PostgreSQL and Redis), nginx. \nWorks with Ollama (local/cloud) and any OpenAI-compatible API. \nOne-command Docker Compose setup.
https://github.com/Evidion-AI/EvidionAI
I'm open-sourcing this because a lot of similar projects are emerging right now, \neach exploring different approaches to autonomous research and agent orchestration.
I'm building this solo, and it seems more valuable to share the approach early \nrather than develop it in isolation \u2014 especially since the space is evolving fast \nand there\u2019s clearly convergent interest in this direction.
Would really appreciate feedback on the agent architecture \u2014 especially the \nSupervisor routing logic, which is currently the most fragile and interesting part."},"title":{"fullyHighlighted":false,"matchLevel":"partial","matchedWords":["multi","agent"],"value":"EvidionAI \u2013 open-source multi-agent research system built on LangGraph"}},"_tags":["story","author_NeuralOperator","story_47510639","ask_hn"],"author":"NeuralOperator","children":[47559657],"created_at":"2026-03-24T22:48:42Z","created_at_i":1774392522,"num_comments":1,"objectID":"47510639","points":1,"story_id":47510639,"story_text":"Hi HN, I built EvidionAI \u2014 an autonomous research pipeline where a Supervisor \norchestrates a loop of specialized agents to answer scientific questions \nend-to-end.
The workflow:\nSupervisor \u2192 Search (DDG + arXiv + Wikipedia) \u2192 Code (Python in sandboxed Docker) \n\u2192 Analysis \u2192 Skeptic \u2192 back to Supervisor if the conclusions don't hold up.
The focus is not just on execution, but on validation \u2014 the system actively \ntries to break its own conclusions via a skeptic loop.
Stack: LangGraph, LangChain, FastAPI, ChromaDB, SQLite (before that, there was PostgreSQL and Redis), nginx. \nWorks with Ollama (local/cloud) and any OpenAI-compatible API. \nOne-command Docker Compose setup.
https://github.com/Evidion-AI/EvidionAI
I'm open-sourcing this because a lot of similar projects are emerging right now, \neach exploring different approaches to autonomous research and agent orchestration.
I'm building this solo, and it seems more valuable to share the approach early \nrather than develop it in isolation \u2014 especially since the space is evolving fast \nand there\u2019s clearly convergent interest in this direction.
Would really appreciate feedback on the agent architecture \u2014 especially the \nSupervisor routing logic, which is currently the most fragile and interesting part.","title":"EvidionAI \u2013 open-source multi-agent research system built on LangGraph","updated_at":"2026-03-29T01:30:28Z"},{"_highlightResult":{"author":{"matchLevel":"none","matchedWords":[],"value":"slogansand"},"story_text":{"fullyHighlighted":false,"matchLevel":"full","matchedWords":["multi","agent","supervisor","architecture"],"value":"Hey HN, author here.\nLoki Mode orchestrates specialized AI agents to take a PRD to deployed product with zero human intervention. But what I'm most proud of is the research foundation - we implemented virtually every scientifically proven pattern from the 2025-2026 AI agent literature.\nFrom Anthropic:
Constitutional AI self-critique against principles\nBuilding Effective Agents evaluator-optimizer pattern\nClaude Code Best Practices explore-plan-code workflow\nVisible Extended Thinking (think, think hard, ultrathink levels)\nEffective Harnesses one-feature-at-a-time pattern
From DeepMind:
SIMA 2 self-improvement loops\nGemini Robotics hierarchical reasoning (planner + executor)\nScalable AI Safety debate-based verification
From OpenAI:
Agents SDK tracing, guardrails, tripwires\nDeep Research adaptive planning with backtracking\nAGENTS.md standardized instructions
From Academic Research:
CONSENSAGENT (ACL 2025): Blind review + Devil's Advocate when unanimous. 30% false positive reduction.\nGoalAct: Global planning \u2192 skill decomposition \u2192 local execution. 12%+ success rate improvement.\nA-Mem: Zettelkasten-style memory linking for episodic\u2192semantic consolidation.\nMulti-Agent Reflexion: Structured debate (Implementer \u2192 Skeptic \u2192 Advocate \u2192 Synthesizer).\nIter-VF: Verify answer only, not reasoning chain. Prevents context overflow.
From Industry:
NVIDIA ToolOrchestra: Three-reward signal (outcome/efficiency/preference), dynamic agent selection\nAWS Bedrock: Routing mode for simple tasks, supervisor mode for complex\nBoris Cherny's self-verification loop (2-3x quality improvement)\nSimon Willison's sub-agents for context isolation
From HN discussions:
"Zero companies without human in the loop" \u2192 confidence-based escalation\nContext curation beats automatic RAG\nFresh contexts yield better results\nLLM-as-judge has shared blind spots \u2192 deterministic validation
The full acknowledgements with links to every paper/resource: https://github.com/asklokesh/claudeskill-loki-mode/blob/main...\nRun: claude --dangerously-skip-permissions then "Loki Mode with PRD at path/to/prd"\nHappy to discuss any of the research or architecture decisions."},"title":{"fullyHighlighted":false,"matchLevel":"partial","matchedWords":["multi","agent"],"value":"Show HN: Research-Backed Multi-Agent System for Autonomous Development"},"url":{"matchLevel":"none","matchedWords":[],"value":"https://github.com/asklokesh/claudeskill-loki-mode"}},"_tags":["story","author_slogansand","story_46547971","show_hn"],"author":"slogansand","children":[46548390],"created_at":"2026-01-08T23:25:22Z","created_at_i":1767914722,"num_comments":1,"objectID":"46547971","points":3,"story_id":46547971,"story_text":"Hey HN, author here.\nLoki Mode orchestrates specialized AI agents to take a PRD to deployed product with zero human intervention. But what I'm most proud of is the research foundation - we implemented virtually every scientifically proven pattern from the 2025-2026 AI agent literature.\nFrom Anthropic:
Constitutional AI self-critique against principles\nBuilding Effective Agents evaluator-optimizer pattern\nClaude Code Best Practices explore-plan-code workflow\nVisible Extended Thinking (think, think hard, ultrathink levels)\nEffective Harnesses one-feature-at-a-time pattern
From DeepMind:
SIMA 2 self-improvement loops\nGemini Robotics hierarchical reasoning (planner + executor)\nScalable AI Safety debate-based verification
From OpenAI:
Agents SDK tracing, guardrails, tripwires\nDeep Research adaptive planning with backtracking\nAGENTS.md standardized instructions
From Academic Research:
CONSENSAGENT (ACL 2025): Blind review + Devil's Advocate when unanimous. 30% false positive reduction.\nGoalAct: Global planning \u2192 skill decomposition \u2192 local execution. 12%+ success rate improvement.\nA-Mem: Zettelkasten-style memory linking for episodic\u2192semantic consolidation.\nMulti-Agent Reflexion: Structured debate (Implementer \u2192 Skeptic \u2192 Advocate \u2192 Synthesizer).\nIter-VF: Verify answer only, not reasoning chain. Prevents context overflow.
From Industry:
NVIDIA ToolOrchestra: Three-reward signal (outcome/efficiency/preference), dynamic agent selection\nAWS Bedrock: Routing mode for simple tasks, supervisor mode for complex\nBoris Cherny's self-verification loop (2-3x quality improvement)\nSimon Willison's sub-agents for context isolation
From HN discussions:
"Zero companies without human in the loop" \u2192 confidence-based escalation\nContext curation beats automatic RAG\nFresh contexts yield better results\nLLM-as-judge has shared blind spots \u2192 deterministic validation
The full acknowledgements with links to every paper/resource: https://github.com/asklokesh/claudeskill-loki-mode/blob/main...\nRun: claude --dangerously-skip-permissions then "Loki Mode with PRD at path/to/prd"\nHappy to discuss any of the research or architecture decisions.","title":"Show HN: Research-Backed Multi-Agent System for Autonomous Development","updated_at":"2026-03-05T23:19:36Z","url":"https://github.com/asklokesh/claudeskill-loki-mode"},{"_highlightResult":{"author":{"matchLevel":"none","matchedWords":[],"value":"Zedmor"},"story_text":{"fullyHighlighted":false,"matchLevel":"full","matchedWords":["multi","agent","supervisor","architecture"],"value":"Hi HN, I'm the author.
I use Claude Code and Codex daily. Running one agent on a task works great. Running three or four in parallel on the same repo? They step on each other's files, nobody checks if the code compiles, and you spend more time coordinating than coding.
Batty is the supervisor layer I built to fix this. You define a team in YAML \u2014 an architect that plans work, a manager that dispatches it, engineers that execute. Batty launches each role in its own tmux pane, isolates engineer work in git worktrees, routes messages between roles, and gates task completion on passing tests.
The interesting part is what it's not: it's not an agent framework, and it doesn't embed any model. It orchestrates existing agent CLIs (Claude Code, Codex, Aider) using tmux as the runtime and git worktrees for isolation. Config is YAML, the kanban board is Markdown (powered by a bundled kanban-md tool), inboxes are Maildir, logs are JSONL. You can `git diff` your entire team state.
Built in Rust, published on crates.io (v0.1.0). The daemon is a synchronous 5-second poll loop \u2014 no async complexity. It watches pane output to detect idle/active/dead agents, reads Claude and Codex session files on disk to reduce false-positive idle detection, and uses a merge lock to serialize concurrent worktree merges.
Some things I learned running multi-agent setups:
- 3-5 parallel engineers is the sweet spot. Beyond that, the codebase itself becomes the bottleneck for absorbing parallel changes.\n- Task decomposition quality matters more than agent count. A good architect prompt outperforms throwing more engineers at bad tasks.\n- Test gating eliminated most of the chaos. Without it, agents "complete" work that breaks everything downstream.\n- You still need to supervise. It's not fire-and-forget \u2014 it's closer to managing a junior team. The leverage is supervising five workstreams instead of doing one.
I know there's prior art in this space \u2014 Tmux-IDE and vibe-kanban both approach multi-agent coordination differently. Batty is more opinionated about supervision: the test gating and communication constraints are first-class, not optional. Different tradeoffs for different workflows.
It's early (v0.1.0). The core loop is solid but the API is still settling. Eight built-in templates range from solo (1 agent) to large (19 agents with three management layers). The architecture diagram in the README shows the full supervision flow.
2-minute demo: https://youtube.com/watch?v=2wmBcUnq0vw\nDocs: https://battysh.github.io/batty
Happy to go deep on the architecture or the worktree strategy. For those running multiple agents: what's the biggest operational pain point?"},"title":{"matchLevel":"none","matchedWords":[],"value":"Show HN: Batty \u2013 Run a team of AI coding agents in tmux with test gating"},"url":{"matchLevel":"none","matchedWords":[],"value":"https://github.com/battysh/batty"}},"_tags":["story","author_Zedmor","story_47638715","show_hn"],"author":"Zedmor","children":[47638728,47638789],"created_at":"2026-04-04T13:02:22Z","created_at_i":1775307742,"num_comments":0,"objectID":"47638715","points":2,"story_id":47638715,"story_text":"Hi HN, I'm the author.
I use Claude Code and Codex daily. Running one agent on a task works great. Running three or four in parallel on the same repo? They step on each other's files, nobody checks if the code compiles, and you spend more time coordinating than coding.
Batty is the supervisor layer I built to fix this. You define a team in YAML \u2014 an architect that plans work, a manager that dispatches it, engineers that execute. Batty launches each role in its own tmux pane, isolates engineer work in git worktrees, routes messages between roles, and gates task completion on passing tests.
The interesting part is what it's not: it's not an agent framework, and it doesn't embed any model. It orchestrates existing agent CLIs (Claude Code, Codex, Aider) using tmux as the runtime and git worktrees for isolation. Config is YAML, the kanban board is Markdown (powered by a bundled kanban-md tool), inboxes are Maildir, logs are JSONL. You can `git diff` your entire team state.
Built in Rust, published on crates.io (v0.1.0). The daemon is a synchronous 5-second poll loop \u2014 no async complexity. It watches pane output to detect idle/active/dead agents, reads Claude and Codex session files on disk to reduce false-positive idle detection, and uses a merge lock to serialize concurrent worktree merges.
Some things I learned running multi-agent setups:
- 3-5 parallel engineers is the sweet spot. Beyond that, the codebase itself becomes the bottleneck for absorbing parallel changes.\n- Task decomposition quality matters more than agent count. A good architect prompt outperforms throwing more engineers at bad tasks.\n- Test gating eliminated most of the chaos. Without it, agents "complete" work that breaks everything downstream.\n- You still need to supervise. It's not fire-and-forget \u2014 it's closer to managing a junior team. The leverage is supervising five workstreams instead of doing one.
I know there's prior art in this space \u2014 Tmux-IDE and vibe-kanban both approach multi-agent coordination differently. Batty is more opinionated about supervision: the test gating and communication constraints are first-class, not optional. Different tradeoffs for different workflows.
It's early (v0.1.0). The core loop is solid but the API is still settling. Eight built-in templates range from solo (1 agent) to large (19 agents with three management layers). The architecture diagram in the README shows the full supervision flow.
2-minute demo: https://youtube.com/watch?v=2wmBcUnq0vw\nDocs: https://battysh.github.io/batty
Happy to go deep on the architecture or the worktree strategy. For those running multiple agents: what's the biggest operational pain point?","title":"Show HN: Batty \u2013 Run a team of AI coding agents in tmux with test gating","updated_at":"2026-04-05T03:27:43Z","url":"https://github.com/battysh/batty"},{"_highlightResult":{"author":{"matchLevel":"none","matchedWords":[],"value":"youknowme123"},"comment_text":{"fullyHighlighted":false,"matchLevel":"full","matchedWords":["multi","agent","supervisor","architecture"],"value":"This is nice, it reminds me of earlier work where DAG-based optimization was used to discover effective multi-agent architectures under supervised learning."},"story_title":{"matchLevel":"none","matchedWords":[],"value":"Show HN: A tiny C program where an LLM rewires its DAG while running"},"story_url":{"matchLevel":"none","matchedWords":[],"value":"https://github.com/kouhxp/liteflow"}},"_tags":["comment","author_youknowme123","story_48017118"],"author":"youknowme123","children":[48165709],"comment_text":"This is nice, it reminds me of earlier work where DAG-based optimization was used to discover effective multi-agent architectures under supervised learning.","created_at":"2026-05-05T13:04:06Z","created_at_i":1777986246,"objectID":"48022008","parent_id":48017118,"story_id":48017118,"story_title":"Show HN: A tiny C program where an LLM rewires its DAG while running","story_url":"https://github.com/kouhxp/liteflow","updated_at":"2026-05-17T03:02:18Z"},{"_highlightResult":{"author":{"matchLevel":"none","matchedWords":[],"value":"breakingnewsai"},"story_text":{"fullyHighlighted":false,"matchLevel":"full","matchedWords":["multi","agent","supervisor","architecture"],"value":"Hi HN,
A quick update for everyone interested in "The Complete LangGraph Blueprint: Build 50+ AI Agents for Business Success": The special free offer for the book ends on December 5th, 2024.
Get the Book: https://www.amazon.com/dp/B0DP69QV7K
This book is a step-by-step guide that takes you from beginner to advanced, helping you build and deploy 50+ real-world AI agents for industries like finance, healthcare, customer service, and more.
What\u2019s Inside?\nCore principles of LangGraph: Nodes, edges, states, and graphs.\nHow to enhance AI agents with memory, multi-agent architectures, and human-in-the-loop capabilities.\nReal-world integrations with APIs and advanced use cases.\nFull code examples and diagrams for every concept.
Why LangGraph?\nIf you\u2019ve used LangChain, you\u2019ll love LangGraph! It goes beyond static chains by introducing dynamic routing, adaptive workflows, and tool selection for intelligent decision-making.\nThe framework is open source, and the book is designed to help developers, startups, and businesses unlock its potential.
Curious before committing? Check out Chapter 10: Plan-and-Execute Agents, which covers:\n- What Plan-and-Execute is and why it\u2019s groundbreaking:\n Discover how this architecture splits reasoning tasks into Planning and Execution phases for superior performance in multi-step workflows.\n- Key differences between Plan-and-Execute and ReAct models:\n Understand why forward-thinking and re-planning make Plan-and-Execute agents more effective in handling complex tasks.
A practical walkthrough for building your own Plan-and-Execute AI agent:\nLearn how to create dynamic agents that plan, execute, and adapt seamlessly, complete with code examples using LangGraph.
Chapter 10: Plan-and-Execute Agents
10.1 Introduction\nThe Plan-and-Execute architecture enhances reasoning tasks by splitting them into two core phases: Planning and Execution. This approach is derived from the Plan-and-Solve methodology, which contrasts with traditional single-step (ReAct) agents. The Plan-and-Solve architecture is particularly useful when dealing with complex multi-step reasoning tasks that require explicit planning for long-term goals.\nIn this chapter, we explore how Plan-and-Execute agents work by devising a multi-step plan and executing it in phases. The agent adapts as necessary, allowing for re-planning in case some steps fail or require more context.\n10.2 Why Use Plan-and-Execute?\nOne of the key issues in multi-step reasoning tasks is that even sophisticated models like GPT-4 often struggle with explicit long-term planning. Plan-and-Execute solves this by:\n\u25cf Breaking down complex tasks into smaller, manageable steps.\n\u25cf Adapting dynamically based on intermediate results.\n\u25cf Revisiting the plan when necessary to adjust or correct steps.\nThis architecture is superior to traditional ReAct (React-then-Act) models as it emphasizes forward-thinking (planning) before acting.\n10.3 Plan-and-Execute Concepts\nFrom the paper Plan-and-Solve Prompting: Improving Zero-Shot Chain-of-Thought Reasoning, the Plan-and-Solve approach addresses the limitations of Zero-shot-CoT (Chain-of-Thought), which typically fails due to:\n1. Calculation Errors: Mistakes in intermediate calculations.\n2. Missing-Step Errors: Skipping important intermediate steps.\n3. Semantic Misunderstandings: Misinterpretation of the problem context.\nTo solve these issues, Plan-and-Solve introduces two key steps:\n1. Planning: Devising a clear plan to divide the overall task into subtasks, ensuring no steps are skipped.\n2. Execution: Executing each subtask and refining the plan if needed.
In the Plan-and-Solve architecture, the agent takes a multi-step approach:\n\u25cf First, it plans out a sequence of steps.\n\u25cf Then, it executes the steps one by one.\n\u25cf If any part of the process fails or if more information is needed, it re-plans the sequence, ensuring robustness and flexibility."},"title":{"matchLevel":"none","matchedWords":[],"value":"Show HN: Last Chance\u2013Free Offer for 'The Complete LangGraph Blueprint' Ends 12/6"},"url":{"matchLevel":"none","matchedWords":[],"value":"https://www.amazon.com/dp/B0DP69QV7K"}},"_tags":["story","author_breakingnewsai","story_42315434","show_hn"],"author":"breakingnewsai","created_at":"2024-12-04T08:07:46Z","created_at_i":1733299666,"num_comments":0,"objectID":"42315434","points":1,"story_id":42315434,"story_text":"Hi HN,
A quick update for everyone interested in "The Complete LangGraph Blueprint: Build 50+ AI Agents for Business Success": The special free offer for the book ends on December 5th, 2024.
Get the Book: https://www.amazon.com/dp/B0DP69QV7K
This book is a step-by-step guide that takes you from beginner to advanced, helping you build and deploy 50+ real-world AI agents for industries like finance, healthcare, customer service, and more.
What\u2019s Inside?\nCore principles of LangGraph: Nodes, edges, states, and graphs.\nHow to enhance AI agents with memory, multi-agent architectures, and human-in-the-loop capabilities.\nReal-world integrations with APIs and advanced use cases.\nFull code examples and diagrams for every concept.
Why LangGraph?\nIf you\u2019ve used LangChain, you\u2019ll love LangGraph! It goes beyond static chains by introducing dynamic routing, adaptive workflows, and tool selection for intelligent decision-making.\nThe framework is open source, and the book is designed to help developers, startups, and businesses unlock its potential.
Curious before committing? Check out Chapter 10: Plan-and-Execute Agents, which covers:\n- What Plan-and-Execute is and why it\u2019s groundbreaking:\n Discover how this architecture splits reasoning tasks into Planning and Execution phases for superior performance in multi-step workflows.\n- Key differences between Plan-and-Execute and ReAct models:\n Understand why forward-thinking and re-planning make Plan-and-Execute agents more effective in handling complex tasks.
A practical walkthrough for building your own Plan-and-Execute AI agent:\nLearn how to create dynamic agents that plan, execute, and adapt seamlessly, complete with code examples using LangGraph.
Chapter 10: Plan-and-Execute Agents
10.1 Introduction\nThe Plan-and-Execute architecture enhances reasoning tasks by splitting them into two core phases: Planning and Execution. This approach is derived from the Plan-and-Solve methodology, which contrasts with traditional single-step (ReAct) agents. The Plan-and-Solve architecture is particularly useful when dealing with complex multi-step reasoning tasks that require explicit planning for long-term goals.\nIn this chapter, we explore how Plan-and-Execute agents work by devising a multi-step plan and executing it in phases. The agent adapts as necessary, allowing for re-planning in case some steps fail or require more context.\n10.2 Why Use Plan-and-Execute?\nOne of the key issues in multi-step reasoning tasks is that even sophisticated models like GPT-4 often struggle with explicit long-term planning. Plan-and-Execute solves this by:\n\u25cf Breaking down complex tasks into smaller, manageable steps.\n\u25cf Adapting dynamically based on intermediate results.\n\u25cf Revisiting the plan when necessary to adjust or correct steps.\nThis architecture is superior to traditional ReAct (React-then-Act) models as it emphasizes forward-thinking (planning) before acting.\n10.3 Plan-and-Execute Concepts\nFrom the paper Plan-and-Solve Prompting: Improving Zero-Shot Chain-of-Thought Reasoning, the Plan-and-Solve approach addresses the limitations of Zero-shot-CoT (Chain-of-Thought), which typically fails due to:\n1. Calculation Errors: Mistakes in intermediate calculations.\n2. Missing-Step Errors: Skipping important intermediate steps.\n3. Semantic Misunderstandings: Misinterpretation of the problem context.\nTo solve these issues, Plan-and-Solve introduces two key steps:\n1. Planning: Devising a clear plan to divide the overall task into subtasks, ensuring no steps are skipped.\n2. Execution: Executing each subtask and refining the plan if needed.
In the Plan-and-Solve architecture, the agent takes a multi-step approach:\n\u25cf First, it plans out a sequence of steps.\n\u25cf Then, it executes the steps one by one.\n\u25cf If any part of the process fails or if more information is needed, it re-plans the sequence, ensuring robustness and flexibility.","title":"Show HN: Last Chance\u2013Free Offer for 'The Complete LangGraph Blueprint' Ends 12/6","updated_at":"2024-12-04T08:10:15Z","url":"https://www.amazon.com/dp/B0DP69QV7K"},{"_highlightResult":{"author":{"matchLevel":"none","matchedWords":[],"value":"mikehostetler"},"story_text":{"fullyHighlighted":false,"matchLevel":"full","matchedWords":["multi","agent","supervisor","architecture"],"value":"Hi HN!
I'm the author of an Elixir Agent Framework called Jido. We reached our 2.0 release this week, shipping a production-hardened framework to build, manage and run Agents on the BEAM.
Jido now supports a host of Agentic features, including:
- Tool Calling and Agent Skills\n- Comprehensive multi-agent support across distributed BEAM processes with Supervision\n- Multiple reasoning strategies including ReAct, Chain of Thought, Tree of Thought, and more\n- Advanced workflow capabilities\n- Durability through a robust Storage and Persistence layer\n- Agentic Memory\n- MCP and Sensors to interface with external services\n- Deep observability and debugging capabilities, including full stack OTel
I know Agent Frameworks can be considered a bit stale, but there hasn't been a major release of a framework on the BEAM. With a growing realization that the architecture of the BEAM is a good match for Agentic workloads, the time was right to make the announcement.
My background is enterprise engineering, distributed systems and Open Source. We've got a strong and growing community of builders committed to the Jido ecosystem. We're looking forward to what gets built on top of Jido!
Come build agents with us!"},"title":{"matchLevel":"none","matchedWords":[],"value":"Show HN: Jido 2.0, Elixir Agent Framework"},"url":{"matchLevel":"none","matchedWords":[],"value":"https://jido.run/blog/jido-2-0-is-here"}},"_tags":["story","author_mikehostetler","story_47263036","show_hn"],"author":"mikehostetler","children":[47263209,47263319,47263799,47264002,47264007,47264010,47264054,47264115,47264116,47264150,47264494,47264678,47264750,47264996,47265270,47266255,47266271,47266723,47267501,47267659,47268319,47268427,47268580,47269807,47269965,47270440,47271109,47271996,47272610,47276862,47283478,47307933],"created_at":"2026-03-05T15:48:52Z","created_at_i":1772725732,"num_comments":65,"objectID":"47263036","points":323,"story_id":47263036,"story_text":"Hi HN!
I'm the author of an Elixir Agent Framework called Jido. We reached our 2.0 release this week, shipping a production-hardened framework to build, manage and run Agents on the BEAM.
Jido now supports a host of Agentic features, including:
- Tool Calling and Agent Skills\n- Comprehensive multi-agent support across distributed BEAM processes with Supervision\n- Multiple reasoning strategies including ReAct, Chain of Thought, Tree of Thought, and more\n- Advanced workflow capabilities\n- Durability through a robust Storage and Persistence layer\n- Agentic Memory\n- MCP and Sensors to interface with external services\n- Deep observability and debugging capabilities, including full stack OTel
I know Agent Frameworks can be considered a bit stale, but there hasn't been a major release of a framework on the BEAM. With a growing realization that the architecture of the BEAM is a good match for Agentic workloads, the time was right to make the announcement.
My background is enterprise engineering, distributed systems and Open Source. We've got a strong and growing community of builders committed to the Jido ecosystem. We're looking forward to what gets built on top of Jido!
Come build agents with us!","title":"Show HN: Jido 2.0, Elixir Agent Framework","updated_at":"2026-08-14T20:57:23Z","url":"https://jido.run/blog/jido-2-0-is-here"},{"_highlightResult":{"author":{"matchLevel":"none","matchedWords":[],"value":"mfkhalil"},"story_text":{"fullyHighlighted":false,"matchLevel":"full","matchedWords":["multi","agent","supervisor","architecture"],"value":"We're the team behind Webhound (https://webhound.ai), an AI agent that builds datasets from the web based on natural language prompts. You describe what you're trying to find. The agent figures out how to structure the data and where to look, then searches, extracts the results, and outputs everything in a CSV you can export.
We've set up a special no-signup version for the HN community at https://hn.webhound.ai - just click "Continue as Guest" to try it without signing up.
Here's a demo: https://youtu.be/fGaRfPdK1Sk
We started building it after getting tired of doing this kind of research manually. Open 50 tabs, copy everything into a spreadsheet, realize it's inconsistent, start over. It felt like something an LLM should be able to handle.
Some examples of how people have used it in the past month:
Competitor analysis: "Create a comparison table of internal tooling platforms (Retool, Appsmith, Superblocks, UI Bakery, BudiBase, etc) with their free plan limits, pricing tiers, onboarding experience, integrations, and how they position themselves on their landing pages." (https://www.webhound.ai/dataset/c67c96a6-9d17-4c91-b9a0-ff69...)
Lead generation: "Find Shopify stores launched recently that sell skincare products. I want the store URLs, founder names, emails, Instagram handles, and product categories." (https://www.webhound.ai/dataset/b63d148a-8895-4aab-ac34-455e...)
Pricing tracking: "Track how the free and paid plans of note-taking apps have changed over the past 6 months using official sites and changelogs. List each app with a timeline of changes and the source for each." (https://www.webhound.ai/dataset/c17e6033-5d00-4e54-baf6-8dea...)
Investor mapping: "Find VCs who led or participated in pre-seed or seed rounds for browser-based devtools startups in the past year. Include the VC name, relevant partners, contact info, and portfolio links for context." (https://www.webhound.ai/dataset/1480c053-d86b-40ce-a620-37fd...)
Research collection: "Get a list of recent arXiv papers on weak supervision in NLP. For each, include the abstract, citation count, publication date, and a GitHub repo if available." (https://www.webhound.ai/dataset/e274ca26-0513-4296-85a5-2b7b...)
Hypothesis testing: "Check if user complaints about Figma's performance on large files have increased in the last 3 months. Search forums like Hacker News, Reddit, and Figma's community site and show the most relevant posts with timestamps and engagement metrics." (https://www.webhound.ai/dataset/42b2de49-acbf-4851-bbb7-080b...)
The first version of Webhound was a single agent running on Claude 4 Sonnet. It worked, but sessions routinely cost over $1100 and it would often get lost in infinite loops. We knew that wasn't sustainable, so we started building around smaller models.
That meant adding more structure. We introduced a multi-agent system to keep it reliable and accurate. There's a main agent, a set of search agents that run subtasks in parallel, a critic agent that keeps things on track, and a validator that double-checks extracted data before saving it. We also gave it a notepad for long-term memory, which helps avoid duplicates and keeps track of what it's already seen.
After switching to Gemini 2.5 Flash and layering in the agent system, we were able to cut costs by more than 30x while also improving speed and output quality.
The system runs in two phases. First is planning, where it decides the schema, how to search, what sources to use, and how to know when it's done. Then comes extraction, where it executes the plan and gathers the data.
It uses a text-based browser we built that renders pages as markdown and extracts content directly. We tried full browser use but it was slower and less reliable. Plain text still works better for this kind of task.
We also built scheduled refreshes to keep datasets up to date and an API so you can integrate the data directly into your workflows.
Right now, everything stays in the agent's context during a run. It starts to break down around 1000-5000 rows depending on the number of attributes. We're working on a better architecture for scaling past that.
We'd love feedback, especially from anyone who's tried solving this problem or built similar tools. Happy to answer anything in the thread.
Thanks!\nMoe"},"title":{"matchLevel":"none","matchedWords":[],"value":"Launch HN: Webhound (YC S23) \u2013 Research agent that builds datasets from the web"}},"_tags":["story","author_mfkhalil","story_45373008","launch_hn"],"author":"mfkhalil","children":[45373562,45374038,45374707,45374848,45374854,45375129,45375145,45375202,45375327,45376224,45376652,45376999,45377283,45377657,45377790,45378199,45379170,45379721,45379780,45379951,45380227,45381177,45382432,45382512,45382836,45383001,45383581,45383588,45383943,45384330,45385617,45386735,45388445,45393091,45396187,45396259,45396275,45396386,45396494,45396589,45397303,45418379,45423797],"created_at":"2025-09-25T14:28:24Z","created_at_i":1758810504,"num_comments":80,"objectID":"45373008","points":112,"story_id":45373008,"story_text":"We're the team behind Webhound (https://webhound.ai), an AI agent that builds datasets from the web based on natural language prompts. You describe what you're trying to find. The agent figures out how to structure the data and where to look, then searches, extracts the results, and outputs everything in a CSV you can export.
We've set up a special no-signup version for the HN community at https://hn.webhound.ai - just click "Continue as Guest" to try it without signing up.
Here's a demo: https://youtu.be/fGaRfPdK1Sk
We started building it after getting tired of doing this kind of research manually. Open 50 tabs, copy everything into a spreadsheet, realize it's inconsistent, start over. It felt like something an LLM should be able to handle.
Some examples of how people have used it in the past month:
Competitor analysis: "Create a comparison table of internal tooling platforms (Retool, Appsmith, Superblocks, UI Bakery, BudiBase, etc) with their free plan limits, pricing tiers, onboarding experience, integrations, and how they position themselves on their landing pages." (https://www.webhound.ai/dataset/c67c96a6-9d17-4c91-b9a0-ff69...)
Lead generation: "Find Shopify stores launched recently that sell skincare products. I want the store URLs, founder names, emails, Instagram handles, and product categories." (https://www.webhound.ai/dataset/b63d148a-8895-4aab-ac34-455e...)
Pricing tracking: "Track how the free and paid plans of note-taking apps have changed over the past 6 months using official sites and changelogs. List each app with a timeline of changes and the source for each." (https://www.webhound.ai/dataset/c17e6033-5d00-4e54-baf6-8dea...)
Investor mapping: "Find VCs who led or participated in pre-seed or seed rounds for browser-based devtools startups in the past year. Include the VC name, relevant partners, contact info, and portfolio links for context." (https://www.webhound.ai/dataset/1480c053-d86b-40ce-a620-37fd...)
Research collection: "Get a list of recent arXiv papers on weak supervision in NLP. For each, include the abstract, citation count, publication date, and a GitHub repo if available." (https://www.webhound.ai/dataset/e274ca26-0513-4296-85a5-2b7b...)
Hypothesis testing: "Check if user complaints about Figma's performance on large files have increased in the last 3 months. Search forums like Hacker News, Reddit, and Figma's community site and show the most relevant posts with timestamps and engagement metrics." (https://www.webhound.ai/dataset/42b2de49-acbf-4851-bbb7-080b...)
The first version of Webhound was a single agent running on Claude 4 Sonnet. It worked, but sessions routinely cost over $1100 and it would often get lost in infinite loops. We knew that wasn't sustainable, so we started building around smaller models.
That meant adding more structure. We introduced a multi-agent system to keep it reliable and accurate. There's a main agent, a set of search agents that run subtasks in parallel, a critic agent that keeps things on track, and a validator that double-checks extracted data before saving it. We also gave it a notepad for long-term memory, which helps avoid duplicates and keeps track of what it's already seen.
After switching to Gemini 2.5 Flash and layering in the agent system, we were able to cut costs by more than 30x while also improving speed and output quality.
The system runs in two phases. First is planning, where it decides the schema, how to search, what sources to use, and how to know when it's done. Then comes extraction, where it executes the plan and gathers the data.
It uses a text-based browser we built that renders pages as markdown and extracts content directly. We tried full browser use but it was slower and less reliable. Plain text still works better for this kind of task.
We also built scheduled refreshes to keep datasets up to date and an API so you can integrate the data directly into your workflows.
Right now, everything stays in the agent's context during a run. It starts to break down around 1000-5000 rows depending on the number of attributes. We're working on a better architecture for scaling past that.
We'd love feedback, especially from anyone who's tried solving this problem or built similar tools. Happy to answer anything in the thread.
Thanks!\nMoe","title":"Launch HN: Webhound (YC S23) \u2013 Research agent that builds datasets from the web","updated_at":"2026-08-01T18:17:22Z"},{"_highlightResult":{"author":{"matchLevel":"none","matchedWords":[],"value":"a24venka"},"story_text":{"fullyHighlighted":false,"matchLevel":"full","matchedWords":["multi","agent","supervisor","architecture"],"value":"Hey HN! We're Ashwin and Akshay from Spine AI (https://www.getspine.ai). Spine Swarm is a multi-agent system that works on an infinite visual canvas to complete complex non-coding projects: competitive analysis, financial modeling, SEO audits, pitch decks, interactive prototypes, and more. Here's a video of it in action: https://www.youtube.com/watch?v=R_2-ggpZz0Q.
We've been friends for over 13 years. We took our first ML course together at NTU, in a part of campus called North Spine, which is where the name comes from. We went through YC in S23 and have spent about 3 years building Spine across many product iterations.
The core idea: chat is the wrong interface for complex AI work. It's a linear thread, and real projects aren't linear. Sure, you can ask a chatbot to reference the financial model from earlier in the thread, or run research and market sizing together, but you're trusting the model to juggle that context implicitly. There's no way to see how it's connecting the pieces, no way to correct one step without rerunning everything, and no way to branch off and explore two strategies side by side. ChatGPT was a demo that blew up, and chat stuck around as the default interface, not because it's the right abstraction. We thought humans and agents needed a real workspace where the structure of the work is explicit and user-controllable, not hidden inside a context window.
So we built an infinite visual canvas where you think in blocks instead of threads. Each block is our abstraction on top of AI models. There are dedicated block types for LLM calls, image generation, web browsing, apps, slides, spreadsheets, and more. Think of them as Lego bricks for AI workflows: each one does something specific, but they can be snapped together and composed in many different ways. You can connect any block to any other block, and that connection guarantees the passing of context regardless of block type. The whole system is model-agnostic, so in a single workflow you can go from an OpenAI LLM call, to an image generation mode like Nano Banana Pro, to Claude generating an interactive app, each block using whatever model fits best. Multiple blocks can fan out from the same input, analyzing it in different ways with different models, then feed their outputs into a downstream block that synthesizes the results.
The first version of the canvas was fully manual. Users entered prompts, chose models, ran blocks, and made connections themselves. It clicked with founders and product managers because they could branch in different directions from the same starting point: take a product idea and generate a prototype in one branch, a PRD in another, a competitive critique in a third, and a pitch deck in a fourth, all sharing the same upstream context. But new users didn't want to learn the interface. They kept asking us to build a chat layer that would generate and connect blocks on their behalf, to replicate the way we were using the tool. So we built that, and in doing so discovered something we didn't expect: the agents were capable of running autonomously for hours, producing complete deliverables. It turned out agents could run longer and keep their context windows clean by delegating work to blocks and storing intermediary context on the canvas, rather than holding everything in a single context window.
Here's how it works now. When you submit a task, a central orchestrator decomposes it into subtasks and delegates each to specialized persona agents. These agents operate on the canvas blocks and can override default settings, primarily the model and prompt, to fit each subtask. Agents pick the best model for each block and sometimes run the same block with multiple models to compare and synthesize outputs. Multiple agents work in parallel when their subtasks don't have dependencies, and downstream agents automatically receive context from upstream work. The user doesn't configure any of this. You can also dispatch multiple tasks at once and the system will queue dependent ones or start independent ones immediately.
Agents aren't fully autonomous by default. Any agent can pause execution and ask the user for clarification or feedback before continuing, which keeps the human in the loop where it matters. And once agents have produced output, you can select a subset of blocks on the canvas and iterate on them through the chat without rerunning the entire workflow.
The canvas gives agents something that filesystems and message-passing don't: a persistent, structured representation of the entire project that any agent can read and contribute to at any point. In typical multi-agent systems, context degrades as it passes between agents. The canvas addresses this because agents store intermediary results in blocks rather than trying to hold everything in memory, and they leave explicit structured handoffs designed to be consumed efficiently by the next agent in the chain. Every step is also fully auditable, so you can trace exactly how each agent arrived at its conclusions.
We ran benchmarks to validate what we were seeing. On Google DeepMind's DeepSearchQA, which is 900 questions spanning 17 fields, each structured as a causal chain where each step depends on completing the previous one, Spine Swarm scored 87.6% on the full dataset with zero human intervention. For the benchmark we used a subset of block types relevant to the questions (LLM calls, web browsing, table) and removed irrelevant ones like document, spreadsheet, and slide generation. We also disabled human clarification so agents ran fully independently. The agents were not just auditable but also state of the art. The auditability also exposed actual errors in an older benchmark (GAIA Level 3), cases where the expected answer was wrong or ambiguous, which you'd never catch with a black-box pipeline. We detail the methodology, architecture, and benchmark errors in the full writeup: https://blog.getspine.ai/spine-swarm-hits-1-on-gaia-level-3-...
Benchmarks measure accuracy on closed-ended questions. Turns out the same architecture also leads to better open-ended outputs like decks, reports, and prototypes with minimal supervision. We've seen early users split into two camps: some watch the agents work and jump in to redirect mid-flow, others queue a task and come back to a finished deliverable. Both work because the canvas preserves the full chain of work, so you can audit or intervene whenever you want.
A good first task to try: give it your website URL and ask for a full SEO analysis, competitive landscape, and a prioritized growth roadmap with a slide deck. You'll see multiple agents spin up on the canvas simultaneously. People have also used it for fundraising pitch decks with financial models, prototyping features from screenshots and PRDs, competitive analysis reports and deep-dive learning plans that research a topic from multiple angles and produce structured material you can explore further.
Pricing is usage-based credits tied to block usage and the underlying models used. Agents tend to use more credits than manual workflows because they're tuned to get you the best possible outcome, which means they pick the best blocks and do more work. Details here: https://www.getspine.ai/pricing. There's a free tier, and one honest caveat: we sized it to let you try a real task, but tasks vary in complexity. If you run out before you've had a proper chance to explore, email us at founders@getspine.ai and we'll work with you.
We'd love your feedback on the experience: what worked, what didn't, and where it fell short. We're also curious how others here approach complex, multi-step AI work beyond coding. What tools are you using, and what breaks first? We'll be in the comments all day."},"title":{"matchLevel":"none","matchedWords":[],"value":"Launch HN: Spine Swarm (YC S23) \u2013 AI agents that collaborate on a visual canvas"},"url":{"matchLevel":"none","matchedWords":[],"value":"https://www.getspine.ai/"}},"_tags":["story","author_a24venka","story_47364116","launch_hn"],"author":"a24venka","children":[47364511,47364602,47364609,47364695,47364780,47364969,47364974,47365088,47365179,47365286,47365316,47365390,47365555,47365572,47365607,47365726,47365727,47365732,47365786,47365822,47366031,47366088,47366264,47366371,47366460,47366500,47366971,47367537,47367621,47368138,47368285,47368413,47368629,47369149,47370764,47370800,47373567,47374157,47374454,47375532,47376801,47377399,47385979,47410341,47412862],"created_at":"2026-03-13T13:22:40Z","created_at_i":1773408160,"num_comments":69,"objectID":"47364116","points":109,"story_id":47364116,"story_text":"Hey HN! We're Ashwin and Akshay from Spine AI (https://www.getspine.ai). Spine Swarm is a multi-agent system that works on an infinite visual canvas to complete complex non-coding projects: competitive analysis, financial modeling, SEO audits, pitch decks, interactive prototypes, and more. Here's a video of it in action: https://www.youtube.com/watch?v=R_2-ggpZz0Q.
We've been friends for over 13 years. We took our first ML course together at NTU, in a part of campus called North Spine, which is where the name comes from. We went through YC in S23 and have spent about 3 years building Spine across many product iterations.
The core idea: chat is the wrong interface for complex AI work. It's a linear thread, and real projects aren't linear. Sure, you can ask a chatbot to reference the financial model from earlier in the thread, or run research and market sizing together, but you're trusting the model to juggle that context implicitly. There's no way to see how it's connecting the pieces, no way to correct one step without rerunning everything, and no way to branch off and explore two strategies side by side. ChatGPT was a demo that blew up, and chat stuck around as the default interface, not because it's the right abstraction. We thought humans and agents needed a real workspace where the structure of the work is explicit and user-controllable, not hidden inside a context window.
So we built an infinite visual canvas where you think in blocks instead of threads. Each block is our abstraction on top of AI models. There are dedicated block types for LLM calls, image generation, web browsing, apps, slides, spreadsheets, and more. Think of them as Lego bricks for AI workflows: each one does something specific, but they can be snapped together and composed in many different ways. You can connect any block to any other block, and that connection guarantees the passing of context regardless of block type. The whole system is model-agnostic, so in a single workflow you can go from an OpenAI LLM call, to an image generation mode like Nano Banana Pro, to Claude generating an interactive app, each block using whatever model fits best. Multiple blocks can fan out from the same input, analyzing it in different ways with different models, then feed their outputs into a downstream block that synthesizes the results.
The first version of the canvas was fully manual. Users entered prompts, chose models, ran blocks, and made connections themselves. It clicked with founders and product managers because they could branch in different directions from the same starting point: take a product idea and generate a prototype in one branch, a PRD in another, a competitive critique in a third, and a pitch deck in a fourth, all sharing the same upstream context. But new users didn't want to learn the interface. They kept asking us to build a chat layer that would generate and connect blocks on their behalf, to replicate the way we were using the tool. So we built that, and in doing so discovered something we didn't expect: the agents were capable of running autonomously for hours, producing complete deliverables. It turned out agents could run longer and keep their context windows clean by delegating work to blocks and storing intermediary context on the canvas, rather than holding everything in a single context window.
Here's how it works now. When you submit a task, a central orchestrator decomposes it into subtasks and delegates each to specialized persona agents. These agents operate on the canvas blocks and can override default settings, primarily the model and prompt, to fit each subtask. Agents pick the best model for each block and sometimes run the same block with multiple models to compare and synthesize outputs. Multiple agents work in parallel when their subtasks don't have dependencies, and downstream agents automatically receive context from upstream work. The user doesn't configure any of this. You can also dispatch multiple tasks at once and the system will queue dependent ones or start independent ones immediately.
Agents aren't fully autonomous by default. Any agent can pause execution and ask the user for clarification or feedback before continuing, which keeps the human in the loop where it matters. And once agents have produced output, you can select a subset of blocks on the canvas and iterate on them through the chat without rerunning the entire workflow.
The canvas gives agents something that filesystems and message-passing don't: a persistent, structured representation of the entire project that any agent can read and contribute to at any point. In typical multi-agent systems, context degrades as it passes between agents. The canvas addresses this because agents store intermediary results in blocks rather than trying to hold everything in memory, and they leave explicit structured handoffs designed to be consumed efficiently by the next agent in the chain. Every step is also fully auditable, so you can trace exactly how each agent arrived at its conclusions.
We ran benchmarks to validate what we were seeing. On Google DeepMind's DeepSearchQA, which is 900 questions spanning 17 fields, each structured as a causal chain where each step depends on completing the previous one, Spine Swarm scored 87.6% on the full dataset with zero human intervention. For the benchmark we used a subset of block types relevant to the questions (LLM calls, web browsing, table) and removed irrelevant ones like document, spreadsheet, and slide generation. We also disabled human clarification so agents ran fully independently. The agents were not just auditable but also state of the art. The auditability also exposed actual errors in an older benchmark (GAIA Level 3), cases where the expected answer was wrong or ambiguous, which you'd never catch with a black-box pipeline. We detail the methodology, architecture, and benchmark errors in the full writeup: https://blog.getspine.ai/spine-swarm-hits-1-on-gaia-level-3-...
Benchmarks measure accuracy on closed-ended questions. Turns out the same architecture also leads to better open-ended outputs like decks, reports, and prototypes with minimal supervision. We've seen early users split into two camps: some watch the agents work and jump in to redirect mid-flow, others queue a task and come back to a finished deliverable. Both work because the canvas preserves the full chain of work, so you can audit or intervene whenever you want.
A good first task to try: give it your website URL and ask for a full SEO analysis, competitive landscape, and a prioritized growth roadmap with a slide deck. You'll see multiple agents spin up on the canvas simultaneously. People have also used it for fundraising pitch decks with financial models, prototyping features from screenshots and PRDs, competitive analysis reports and deep-dive learning plans that research a topic from multiple angles and produce structured material you can explore further.
Pricing is usage-based credits tied to block usage and the underlying models used. Agents tend to use more credits than manual workflows because they're tuned to get you the best possible outcome, which means they pick the best blocks and do more work. Details here: https://www.getspine.ai/pricing. There's a free tier, and one honest caveat: we sized it to let you try a real task, but tasks vary in complexity. If you run out before you've had a proper chance to explore, email us at founders@getspine.ai and we'll work with you.
We'd love your feedback on the experience: what worked, what didn't, and where it fell short. We're also curious how others here approach complex, multi-step AI work beyond coding. What tools are you using, and what breaks first? We'll be in the comments all day.","title":"Launch HN: Spine Swarm (YC S23) \u2013 AI agents that collaborate on a visual canvas","updated_at":"2026-03-26T23:51:20Z","url":"https://www.getspine.ai/"},{"_highlightResult":{"author":{"matchLevel":"none","matchedWords":[],"value":"AGI______"},"story_text":{"fullyHighlighted":false,"matchLevel":"full","matchedWords":["multi","agent","supervisor","architecture"],"value":"AI_Ecosystem\n\u251c\u2500\u2500 MultiAgent_Systems\n\u2502 \u251c\u2500\u2500 Autonomous_Agents\n\u2502 \u2502 \u251c\u2500\u2500 WebSurfer\n\u2502 \u2502 \u251c\u2500\u2500 Coder\n\u2502 \u2502 \u251c\u2500\u2500 FileSurfer\n\u2502 \u2502 \u251c\u2500\u2500 Mariner_Agent\n\u2502 \u251c\u2500\u2500 Orchestrator_Agent (Prefrontal Cortex Function)\n\u2502 \u251c\u2500\u2500 Task_Ledger \n\u2502 \u251c\u2500\u2500 Progress_Ledger (Execution Tracking)\n\u2502\n\u251c\u2500\u2500 Memory_Knowledge_Systems\n\u2502 \u251c\u2500\u2500 Memoripy (Hierarchical Memory)\n\u2502 \u2502 \u251c\u2500\u2500 Short-Term_Memory (LTCNs - Liquid Time Constant Networks)\n\u2502 \u2502 \u251c\u2500\u2500 Working_Memory (NAMMs - Non-Associative Memory Modules)\n\u2502 \u2502 \u251c\u2500\u2500 Long-Term_Memory (DNCs - Differentiable Neural Computers)\n\u2502 \u251c\u2500\u2500 Hierarchical_Memory\n\u2502 \u2502 \u251c\u2500\u2500 Dynamic_Memory_Prioritization\n\u2502 \u2502 \u251c\u2500\u2500 Memory_Gating (Task-Sensitive Retrieval)\n\u2502 \u2502 \u251c\u2500\u2500 Vector_Database_Integration\n\u2502\n\u251c\u2500\u2500 Learning_Optimization_Frameworks\n\u2502 \u251c\u2500\u2500 SDRO_Framework (Surprise-Driven Reflective Optimization)\n\u2502 \u2502 \u251c\u2500\u2500 Local_Surprise (Agent-Level Adaptation)\n\u2502 \u2502 \u251c\u2500\u2500 Global_Surprise (System-Wide Reconfiguration)\n\u2502 \u2502 \u251c\u2500\u2500 Novelty_Surprise (Exploration & Skill Acquisition)\n\u2502 \u251c\u2500\u2500 Predictive_Coding (Free Energy Minimization)\n\u2502 \u251c\u2500\u2500 Free_Energy_Principle (Perception & Action Optimization)\n\u2502\n\u251c\u2500\u2500 Knowledge_Representation\n\u2502 \u251c\u2500\u2500 Polysynthetic_Language (Hyper-Efficient AI Communication)\n\u2502 \u251c\u2500\u2500 Glyph_Compression (SynthLang/Glyphstral Model 93% Token Reduction)\n\u2502 \u251c\u2500\u2500 AST_Encoding (Abstract Syntax Tree Knowledge Representation)\n\u2502 \u2502 \u251c\u2500\u2500 Set_Theory (Logical Foundations)\n\u2502 \u2502 \u251c\u2500\u2500 Category_Theory (Complex Mappings)\n\u2502 \u2502 \u251c\u2500\u2500 Topology (Spatial & Conceptual Representation)\n\u2502\n\u251c\u2500\u2500 Hybrid_AI_Architecture\n\u2502 \u251c\u2500\u2500 Neural_Module (LLMs, Transformers)\n\u2502 \u251c\u2500\u2500 Symbolic_Engine (Rule-Based Reasoning)\n\u2502 \u251c\u2500\u2500 TPTrans (Transformer-Based Symbol-Embedding Bridge)\n\u2502 \u251c\u2500\u2500 Hybrid_AI (Associative Logic + Machine Learning)\n\u2502\n\u251c\u2500\u2500 Federated_Decentralized_Learning\n\u2502 \u251c\u2500\u2500 Crypto_Bounties (AI Skill Acquisition & Rewards)\n\u2502 \u251c\u2500\u2500 zk-SNARKs (Privacy-Preserving AI Training)\n\u2502 \u251c\u2500\u2500 Federated_Neuroplasticity (Cross-Agent Adaptation)\n\u2502\n\u251c\u2500\u2500 Hardware_Software_CoDesign\n\u2502 \u251c\u2500\u2500 CXL (Neural Connectivity - Compute Express Link)\n\u2502 \u251c\u2500\u2500 HBM3 (High-Speed Synaptic Memory)\n\u2502 \u251c\u2500\u2500 NAMMs (Adaptive Working Memory Modules)\n\u2502 \u251c\u2500\u2500 Real-Time Parallel Processing (LTCNs + GPU Acceleration)\n\u2502\n\u251c\u2500\u2500 Reinforcement_Learning\n\u2502 \u251c\u2500\u2500 SMiRL (Surprise-Minimizing Reinforcement Learning)\n\u2502 \u2502 \u251c\u2500\u2500 Epistemic_Surprise (Model Uncertainty Detection)\n\u2502 \u2502 \u251c\u2500\u2500 Aleatoric_Surprise (Stochasticity Estimation)\n\u2502 \u2502 \u251c\u2500\u2500 Novelty_Surprise (Unfamiliar Pattern Recognition)\n\u2502\n\u251c\u2500\u2500 AI_Performance_Adaptability\n\u2502 \u251c\u2500\u2500 MultiAgent_Coordination (Self-Optimizing AI System)\n\u2502 \u251c\u2500\u2500 MetaLearning (Learning to Learn)\n\u2502 \u251c\u2500\u2500 Hierarchical_Task_Learning (Contextual Skill Acquisition)\n\u2502\n\u2502\n\u251c\u2500\u2500 HumanTask_DataCollection\n\u2502 \u251c\u2500\u2500 HumanTaskRecording (Real-Time AI Supervision)\n\u2502 \u2502 \u251c\u2500\u2500 SpreadsheetManipulation (Excel)\n\u2502 \u2502 \u251c\u2500\u2500 PowerPointCreation (Slides, Presentations)\n\u2502 \u2502 \u251c\u2500\u2500 CanvaDesign (Graphic Creation)\n\u2502 \u2502 \u251c\u2500\u2500 VideoEditing\n\u2502 \u251c\u2500\u2500 EEGRecording (Brain Activity Mapping During Tasks)\n\u2502 \u251c\u2500\u2500 GUI_TARS_Integration (Graphical User Interface Task Automation)\n\u2502\n\u251c\u2500\u2500 DataAssociation (Multimodal Learning)\n\u2502 \u251c\u2500\u2500 SensoryInputProcessing (Vision, Audio, Haptics)\n\u2502 \u251c\u2500\u2500 TextualDataIntegration (LLM-Based Context)\n\u2502 \u251c\u2500\u2500 CrossDomain_AssociationLearning (Linking Concepts Across Modalities)\n\u2502\n\u251c\u2500\u2500 ModelArchitecture\n\u2502 \u251c\u2500\u2500 EncoderDecoder (All-in-One Model for Multi-Modal Learning)\n\u2502 \u2502 \u251c\u2500\u2500 MultiModalEncoder (Text, Image, Video, EEG, GUI Data)\n\u2502 \u2502 \u2514\u2500\u2500 MultiModalDecoder (Task-Specific Generative AI)\n\u2502\n\u251c\u2500\u2500 GUI-TARS_Integration\n\u2502 \u251c\u2500\u2500 ReinforcementLearningModule (Self-Improving UI Agents)\n\u2502 \u251c\u2500\u2500 GUIAutomationModule (Real-Time Interface Adaptation)\n\u2502\n\u2514\u2500\u2500 LearningFramework\n \u251c\u2500\u2500 CrossDomainAssociationLearning (Multi-Modal Knowledge Fusion)\n \u251c\u2500\u2500 Surprise-DrivenReflectiveOptimization (Meta-Cognitive Feedback Loops)\n \u251c\u2500\u2500 FederatedNeuroplasticity (Distributed AI Learning for Generalization)"},"title":{"matchLevel":"none","matchedWords":[],"value":"Plug this into your LLM advanced AI Agent research AST"}},"_tags":["story","author_AGI______","story_43153859","ask_hn"],"author":"AGI______","created_at":"2025-02-23T22:31:44Z","created_at_i":1740349904,"num_comments":0,"objectID":"43153859","points":2,"story_id":43153859,"story_text":"AI_Ecosystem\n\u251c\u2500\u2500 MultiAgent_Systems\n\u2502 \u251c\u2500\u2500 Autonomous_Agents\n\u2502 \u2502 \u251c\u2500\u2500 WebSurfer\n\u2502 \u2502 \u251c\u2500\u2500 Coder\n\u2502 \u2502 \u251c\u2500\u2500 FileSurfer\n\u2502 \u2502 \u251c\u2500\u2500 Mariner_Agent\n\u2502 \u251c\u2500\u2500 Orchestrator_Agent (Prefrontal Cortex Function)\n\u2502 \u251c\u2500\u2500 Task_Ledger \n\u2502 \u251c\u2500\u2500 Progress_Ledger (Execution Tracking)\n\u2502\n\u251c\u2500\u2500 Memory_Knowledge_Systems\n\u2502 \u251c\u2500\u2500 Memoripy (Hierarchical Memory)\n\u2502 \u2502 \u251c\u2500\u2500 Short-Term_Memory (LTCNs - Liquid Time Constant Networks)\n\u2502 \u2502 \u251c\u2500\u2500 Working_Memory (NAMMs - Non-Associative Memory Modules)\n\u2502 \u2502 \u251c\u2500\u2500 Long-Term_Memory (DNCs - Differentiable Neural Computers)\n\u2502 \u251c\u2500\u2500 Hierarchical_Memory\n\u2502 \u2502 \u251c\u2500\u2500 Dynamic_Memory_Prioritization\n\u2502 \u2502 \u251c\u2500\u2500 Memory_Gating (Task-Sensitive Retrieval)\n\u2502 \u2502 \u251c\u2500\u2500 Vector_Database_Integration\n\u2502\n\u251c\u2500\u2500 Learning_Optimization_Frameworks\n\u2502 \u251c\u2500\u2500 SDRO_Framework (Surprise-Driven Reflective Optimization)\n\u2502 \u2502 \u251c\u2500\u2500 Local_Surprise (Agent-Level Adaptation)\n\u2502 \u2502 \u251c\u2500\u2500 Global_Surprise (System-Wide Reconfiguration)\n\u2502 \u2502 \u251c\u2500\u2500 Novelty_Surprise (Exploration & Skill Acquisition)\n\u2502 \u251c\u2500\u2500 Predictive_Coding (Free Energy Minimization)\n\u2502 \u251c\u2500\u2500 Free_Energy_Principle (Perception & Action Optimization)\n\u2502\n\u251c\u2500\u2500 Knowledge_Representation\n\u2502 \u251c\u2500\u2500 Polysynthetic_Language (Hyper-Efficient AI Communication)\n\u2502 \u251c\u2500\u2500 Glyph_Compression (SynthLang/Glyphstral Model 93% Token Reduction)\n\u2502 \u251c\u2500\u2500 AST_Encoding (Abstract Syntax Tree Knowledge Representation)\n\u2502 \u2502 \u251c\u2500\u2500 Set_Theory (Logical Foundations)\n\u2502 \u2502 \u251c\u2500\u2500 Category_Theory (Complex Mappings)\n\u2502 \u2502 \u251c\u2500\u2500 Topology (Spatial & Conceptual Representation)\n\u2502\n\u251c\u2500\u2500 Hybrid_AI_Architecture\n\u2502 \u251c\u2500\u2500 Neural_Module (LLMs, Transformers)\n\u2502 \u251c\u2500\u2500 Symbolic_Engine (Rule-Based Reasoning)\n\u2502 \u251c\u2500\u2500 TPTrans (Transformer-Based Symbol-Embedding Bridge)\n\u2502 \u251c\u2500\u2500 Hybrid_AI (Associative Logic + Machine Learning)\n\u2502\n\u251c\u2500\u2500 Federated_Decentralized_Learning\n\u2502 \u251c\u2500\u2500 Crypto_Bounties (AI Skill Acquisition & Rewards)\n\u2502 \u251c\u2500\u2500 zk-SNARKs (Privacy-Preserving AI Training)\n\u2502 \u251c\u2500\u2500 Federated_Neuroplasticity (Cross-Agent Adaptation)\n\u2502\n\u251c\u2500\u2500 Hardware_Software_CoDesign\n\u2502 \u251c\u2500\u2500 CXL (Neural Connectivity - Compute Express Link)\n\u2502 \u251c\u2500\u2500 HBM3 (High-Speed Synaptic Memory)\n\u2502 \u251c\u2500\u2500 NAMMs (Adaptive Working Memory Modules)\n\u2502 \u251c\u2500\u2500 Real-Time Parallel Processing (LTCNs + GPU Acceleration)\n\u2502\n\u251c\u2500\u2500 Reinforcement_Learning\n\u2502 \u251c\u2500\u2500 SMiRL (Surprise-Minimizing Reinforcement Learning)\n\u2502 \u2502 \u251c\u2500\u2500 Epistemic_Surprise (Model Uncertainty Detection)\n\u2502 \u2502 \u251c\u2500\u2500 Aleatoric_Surprise (Stochasticity Estimation)\n\u2502 \u2502 \u251c\u2500\u2500 Novelty_Surprise (Unfamiliar Pattern Recognition)\n\u2502\n\u251c\u2500\u2500 AI_Performance_Adaptability\n\u2502 \u251c\u2500\u2500 MultiAgent_Coordination (Self-Optimizing AI System)\n\u2502 \u251c\u2500\u2500 MetaLearning (Learning to Learn)\n\u2502 \u251c\u2500\u2500 Hierarchical_Task_Learning (Contextual Skill Acquisition)\n\u2502\n\u2502\n\u251c\u2500\u2500 HumanTask_DataCollection\n\u2502 \u251c\u2500\u2500 HumanTaskRecording (Real-Time AI Supervision)\n\u2502 \u2502 \u251c\u2500\u2500 SpreadsheetManipulation (Excel)\n\u2502 \u2502 \u251c\u2500\u2500 PowerPointCreation (Slides, Presentations)\n\u2502 \u2502 \u251c\u2500\u2500 CanvaDesign (Graphic Creation)\n\u2502 \u2502 \u251c\u2500\u2500 VideoEditing\n\u2502 \u251c\u2500\u2500 EEGRecording (Brain Activity Mapping During Tasks)\n\u2502 \u251c\u2500\u2500 GUI_TARS_Integration (Graphical User Interface Task Automation)\n\u2502\n\u251c\u2500\u2500 DataAssociation (Multimodal Learning)\n\u2502 \u251c\u2500\u2500 SensoryInputProcessing (Vision, Audio, Haptics)\n\u2502 \u251c\u2500\u2500 TextualDataIntegration (LLM-Based Context)\n\u2502 \u251c\u2500\u2500 CrossDomain_AssociationLearning (Linking Concepts Across Modalities)\n\u2502\n\u251c\u2500\u2500 ModelArchitecture\n\u2502 \u251c\u2500\u2500 EncoderDecoder (All-in-One Model for Multi-Modal Learning)\n\u2502 \u2502 \u251c\u2500\u2500 MultiModalEncoder (Text, Image, Video, EEG, GUI Data)\n\u2502 \u2502 \u2514\u2500\u2500 MultiModalDecoder (Task-Specific Generative AI)\n\u2502\n\u251c\u2500\u2500 GUI-TARS_Integration\n\u2502 \u251c\u2500\u2500 ReinforcementLearningModule (Self-Improving UI Agents)\n\u2502 \u251c\u2500\u2500 GUIAutomationModule (Real-Time Interface Adaptation)\n\u2502\n\u2514\u2500\u2500 LearningFramework\n \u251c\u2500\u2500 CrossDomainAssociationLearning (Multi-Modal Knowledge Fusion)\n \u251c\u2500\u2500 Surprise-DrivenReflectiveOptimization (Meta-Cognitive Feedback Loops)\n \u251c\u2500\u2500 FederatedNeuroplasticity (Distributed AI Learning for Generalization)","title":"Plug this into your LLM advanced AI Agent research AST","updated_at":"2025-05-06T15:52:48Z"},{"_highlightResult":{"author":{"matchLevel":"none","matchedWords":[],"value":"govindgupta"},"comment_text":{"fullyHighlighted":false,"matchLevel":"full","matchedWords":["multi","agent","supervisor","architecture"],"value":"Location: India (IST, UTC+5:30)
Remote: Yes (flexible with US/EU overlap)
Willing to relocate: No
Technologies: Claude API, Claude Code, Cursor, MCP servers, LangGraph, CrewAI, OpenAI Agents SDK, AutoGen, LangChain, LlamaIndex, RAG pipelines, multi-agent orchestration, LLM integration, Python, FastAPI, Django, Node.js, PostgreSQL, pgvector, Next.js, React, TypeScript, Supabase, Stripe, AWS, Docker, Vercel, CI/CD
R\u00e9sum\u00e9/CV: https://govindgupta.com
Email: govind@govindgupta.com
GitHub: https://github.com/guptagovind
LinkedIn: https://linkedin.com/in/govind-gupta
16 years shipping production systems across startups and enterprises, including 2.5 years onsite at US enterprises ADP and Time Warner Cable. I build agentic AI systems that run in production daily and full-stack platforms that serve thousands of users at scale.
What I've shipped:
1. Multi-agent feature development system on LangGraph, runs daily in production. Supervised agent team, Postgres checkpointing, pgvector RAG, custom MCP servers, LangSmith eval harness, human approval gates.
2. https://turtlemint.com, insurance platform scaled to 10,000+ monthly users
3. https://ontosight.ai, life sciences AI platform, document analysis and verification workflows
4. Enterprise network management platform serving real-time dashboards across 10,000+ device networks
5. AI-powered development tools used daily by distributed engineering teams
I own architecture decisions, lead and mentor engineering teams, and stay hands-on. Comfortable operating at startup speed and enterprise complexity.
Open to contract work, fractional technical lead engagements, or the right full-time remote opportunity.
govind@govindgupta.com"},"story_title":{"matchLevel":"none","matchedWords":[],"value":"Ask HN: Who wants to be hired? (August 2026)"}},"_tags":["comment","author_govindgupta","story_49156682"],"author":"govindgupta","comment_text":"Location: India (IST, UTC+5:30)
Remote: Yes (flexible with US/EU overlap)
Willing to relocate: No
Technologies: Claude API, Claude Code, Cursor, MCP servers, LangGraph, CrewAI, OpenAI Agents SDK, AutoGen, LangChain, LlamaIndex, RAG pipelines, multi-agent orchestration, LLM integration, Python, FastAPI, Django, Node.js, PostgreSQL, pgvector, Next.js, React, TypeScript, Supabase, Stripe, AWS, Docker, Vercel, CI/CD
R\u00e9sum\u00e9/CV: https://govindgupta.com
Email: govind@govindgupta.com
GitHub: https://github.com/guptagovind
LinkedIn: https://linkedin.com/in/govind-gupta
16 years shipping production systems across startups and enterprises, including 2.5 years onsite at US enterprises ADP and Time Warner Cable. I build agentic AI systems that run in production daily and full-stack platforms that serve thousands of users at scale.
What I've shipped:
1. Multi-agent feature development system on LangGraph, runs daily in production. Supervised agent team, Postgres checkpointing, pgvector RAG, custom MCP servers, LangSmith eval harness, human approval gates.
2. https://turtlemint.com, insurance platform scaled to 10,000+ monthly users
3. https://ontosight.ai, life sciences AI platform, document analysis and verification workflows
4. Enterprise network management platform serving real-time dashboards across 10,000+ device networks
5. AI-powered development tools used daily by distributed engineering teams
I own architecture decisions, lead and mentor engineering teams, and stay hands-on. Comfortable operating at startup speed and enterprise complexity.
Open to contract work, fractional technical lead engagements, or the right full-time remote opportunity.
govind@govindgupta.com","created_at":"2026-08-03T16:49:31Z","created_at_i":1785775771,"objectID":"49158257","parent_id":49156682,"story_id":49156682,"story_title":"Ask HN: Who wants to be hired? (August 2026)","updated_at":"2026-08-03T16:55:43Z"},{"_highlightResult":{"author":{"matchLevel":"none","matchedWords":[],"value":"lelanthran"},"comment_text":{"fullyHighlighted":false,"matchLevel":"full","matchedWords":["multi","agent","supervisor","architecture"],"value":"> I wonder how well an LLM would do for a new CPU architecture for which no C compiler exists yet, just assembler.
Quite well, possibly.
Look, I wasn't even aware of this until it popped up a few days ago on HN, I am not privy to the details of Anthropics engineers in general, or the specific engineer who curated this marathon multi-agent dev cycle, but I can tell you how anyone familiar with compilers or programming language development will proceed:
1. Vibe an IL (intermediate language) specification into existence (even if it is only held in RAM as structures/objects)
2. Vibe some utility functions for the IL (dump, search, etc)
3. Vibe a set of backends, that take IL as input and emit ISA (Instruction Set Architecture), with a set of tests for each target ISA
4. Vibe a front-end that takes C language input and outputs the IL, with a set of tests for each language construct.
(Everything from #2 onwards can be done in parallel)
I have no reason to believe that the engineer who vibe-coded CCC is anything other than competent and skillful, so lets assume he did at least the above (TBH, he probably did more)[1].
This means that CCC has, in its code, everything needed to vibe a never-before-seen ISA, given the ISA spec. It also means it has everything needed to support a new front-end language as long as it is similar enough to C (i.e. language constructs can map to the IL constructs).
So, this should be pretty easy to expand on, because I find it unlikely that the engineer who supervised/curated the process would be anything less than an expert.
The only flaw in my argument is that I am assuming that effort from CC was so large because it did the src -> IL -> ISA route. If my assumption is wrong, it might be well-nigh impossible to add support for a new ISA.
------------------------------
[1] When I agreed to a previous poster on a previous thread that I can recreate the functionality of CCC for $20k, these are the steps I would have followed, except I would not have LLM-generated anything."},"story_title":{"matchLevel":"none","matchedWords":[],"value":"Claude\u2019s C Compiler vs. GCC"},"story_url":{"matchLevel":"none","matchedWords":[],"value":"https://harshanu.space/en/tech/ccc-vs-gcc/"}},"_tags":["comment","author_lelanthran","story_46941603"],"author":"lelanthran","comment_text":"> I wonder how well an LLM would do for a new CPU architecture for which no C compiler exists yet, just assembler.
Quite well, possibly.
Look, I wasn't even aware of this until it popped up a few days ago on HN, I am not privy to the details of Anthropics engineers in general, or the specific engineer who curated this marathon multi-agent dev cycle, but I can tell you how anyone familiar with compilers or programming language development will proceed:
1. Vibe an IL (intermediate language) specification into existence (even if it is only held in RAM as structures/objects)
2. Vibe some utility functions for the IL (dump, search, etc)
3. Vibe a set of backends, that take IL as input and emit ISA (Instruction Set Architecture), with a set of tests for each target ISA
4. Vibe a front-end that takes C language input and outputs the IL, with a set of tests for each language construct.
(Everything from #2 onwards can be done in parallel)
I have no reason to believe that the engineer who vibe-coded CCC is anything other than competent and skillful, so lets assume he did at least the above (TBH, he probably did more)[1].
This means that CCC has, in its code, everything needed to vibe a never-before-seen ISA, given the ISA spec. It also means it has everything needed to support a new front-end language as long as it is similar enough to C (i.e. language constructs can map to the IL constructs).
So, this should be pretty easy to expand on, because I find it unlikely that the engineer who supervised/curated the process would be anything less than an expert.
The only flaw in my argument is that I am assuming that effort from CC was so large because it did the src -> IL -> ISA route. If my assumption is wrong, it might be well-nigh impossible to add support for a new ISA.
------------------------------
[1] When I agreed to a previous poster on a previous thread that I can recreate the functionality of CCC for $20k, these are the steps I would have followed, except I would not have LLM-generated anything.","created_at":"2026-02-09T10:50:11Z","created_at_i":1770634211,"objectID":"46943839","parent_id":46942303,"story_id":46941603,"story_title":"Claude\u2019s C Compiler vs. GCC","story_url":"https://harshanu.space/en/tech/ccc-vs-gcc/","updated_at":"2026-03-05T23:33:00Z"},{"_highlightResult":{"author":{"matchLevel":"none","matchedWords":[],"value":"matiasmolinas"},"comment_text":{"fullyHighlighted":false,"matchLevel":"full","matchedWords":["multi","agent","supervisor","architecture"],"value":"Anthropic just launched a "sub-agents" feature for Claude Code, which lets you define specialized agents in Markdown files that the main agent can delegate tasks to.\nThis is interesting to me because a month ago, I launched an experimental project called LLMunix. The core idea was to build an OS-like framework for an LLM where agents and tools are defined as simple, version-controllable Markdown files. The system would achieve a user's goal by creating a plan and then orchestrating these components.\nA key part of the architecture was delegation. Since Claude didn't have this natively, I built a run_agent tool. It's essentially a shell script that takes the path to an agent's Markdown file and some JSON arguments, then spawns a separate, non-interactive Gemini CLI or Claude Code sub-process to execute it. It was a hack, but it worked to prove the concept of a higher-level orchestrator using specialized, file-based agents.\nThe new native implementation is strikingly similar:\nAgents are defined in Markdown files with YAML frontmatter.\nThey live in a specific directory (.claude/agents/).\nThe orchestrator (Claude Code itself) delegates to them based on their description.\nThe native version is obviously superior \u2013 it offers true context isolation, proper tool permissioning, and is much cleaner than my sub-process hack.\nI'm now planning to refactor LLMunix to use these native sub-agents directly. It will simplify the codebase significantly and make the project a much better example of this emerging architectural pattern.\nTo me, this confirms that the future of complex AI work isn't a single monolithic model, but an orchestrator delegating tasks to a collection of specialized, human-readable components. It's a fun bit of parallel evolution, and I'm excited to build on top of the real thing now.
Curious to hear what others think of this multi-agent, file-based approach."},"story_title":{"matchLevel":"none","matchedWords":[],"value":"[dead]"}},"_tags":["comment","author_matiasmolinas","story_44683129"],"author":"matiasmolinas","comment_text":"Anthropic just launched a "sub-agents" feature for Claude Code, which lets you define specialized agents in Markdown files that the main agent can delegate tasks to.\nThis is interesting to me because a month ago, I launched an experimental project called LLMunix. The core idea was to build an OS-like framework for an LLM where agents and tools are defined as simple, version-controllable Markdown files. The system would achieve a user's goal by creating a plan and then orchestrating these components.\nA key part of the architecture was delegation. Since Claude didn't have this natively, I built a run_agent tool. It's essentially a shell script that takes the path to an agent's Markdown file and some JSON arguments, then spawns a separate, non-interactive Gemini CLI or Claude Code sub-process to execute it. It was a hack, but it worked to prove the concept of a higher-level orchestrator using specialized, file-based agents.\nThe new native implementation is strikingly similar:\nAgents are defined in Markdown files with YAML frontmatter.\nThey live in a specific directory (.claude/agents/).\nThe orchestrator (Claude Code itself) delegates to them based on their description.\nThe native version is obviously superior \u2013 it offers true context isolation, proper tool permissioning, and is much cleaner than my sub-process hack.\nI'm now planning to refactor LLMunix to use these native sub-agents directly. It will simplify the codebase significantly and make the project a much better example of this emerging architectural pattern.\nTo me, this confirms that the future of complex AI work isn't a single monolithic model, but an orchestrator delegating tasks to a collection of specialized, human-readable components. It's a fun bit of parallel evolution, and I'm excited to build on top of the real thing now.
Curious to hear what others think of this multi-agent, file-based approach.","created_at":"2025-07-25T13:51:23Z","created_at_i":1753451483,"objectID":"44683130","parent_id":44683129,"story_id":44683129,"story_title":"[dead]","updated_at":"2025-07-25T13:52:22Z"},{"_highlightResult":{"author":{"matchLevel":"none","matchedWords":[],"value":"wangyu164"},"comment_text":{"fullyHighlighted":false,"matchLevel":"full","matchedWords":["multi","agent","supervisor","architecture"],"value":"MIRIX is a multi-agent personal assistant with the world's most advanced memory system for LLM agents. It redefines AI memory by enabling language models to remember across diverse modalities, including screen activity. Key features include a modular architecture with six distinct memory types (Core, Episodic, Semantic, Procedural, Resource, Knowledge Vault), privacy-first design with local data storage, and superior performance: 35% higher than RAG baseline with 99.9% storage reduction, and 85.4% accuracy on memory benchmarks, outperforming MemQS, Mem0, and Zep. It processes screen captures and contextual inputs to generate organized, searchable knowledge, providing real-time, low-latency memory retrieval. Learn more at https://mirix.io/"},"story_title":{"matchLevel":"none","matchedWords":[],"value":"Building Your Personal Assistant with Multi-Modal Memory"},"story_url":{"matchLevel":"none","matchedWords":[],"value":"https://mirix.io/"}},"_tags":["comment","author_wangyu164","story_44610059"],"author":"wangyu164","comment_text":"MIRIX is a multi-agent personal assistant with the world's most advanced memory system for LLM agents. It redefines AI memory by enabling language models to remember across diverse modalities, including screen activity. Key features include a modular architecture with six distinct memory types (Core, Episodic, Semantic, Procedural, Resource, Knowledge Vault), privacy-first design with local data storage, and superior performance: 35% higher than RAG baseline with 99.9% storage reduction, and 85.4% accuracy on memory benchmarks, outperforming MemQS, Mem0, and Zep. It processes screen captures and contextual inputs to generate organized, searchable knowledge, providing real-time, low-latency memory retrieval. Learn more at https://mirix.io/","created_at":"2025-07-18T21:31:06Z","created_at_i":1752874266,"objectID":"44610060","parent_id":44610059,"story_id":44610059,"story_title":"Building Your Personal Assistant with Multi-Modal Memory","story_url":"https://mirix.io/","updated_at":"2025-07-18T21:35:10Z"}],"hitsPerPage":20,"nbHits":14,"nbPages":1,"page":0,"params":"query=multi-agent+supervisor+architecture&advancedSyntax=true&analyticsTags=backend","processingTimeMS":29,"processingTimingsMS":{"_request":{"queue":4,"roundTrip":18},"afterFetch":{"format":{"highlighting":3,"total":3},"merge":{"mergeLoop":{"total":1},"total":1},"total":1},"fetch":{"query":16,"scanning":10,"total":27},"total":29},"query":"multi-agent supervisor architecture","serverTimeMS":36}