Project manager agent in Hermes: task decomposition and human approvalArticle · digest for November 7
Idea Foundry engineering pipeline for step-by-step project decomposition
Article4 sections≈ 6 min

Project manager agent in Hermes: task decomposition and human approval

Anyone who has tried asking a neural network to build a large project has run into the overloaded-intern effect. You type an ambitious request into the chat: "Build me a client portal with lead generation, a cost calculator, and CRM integration." The model cheerfully reports "On it!", starts generating thousands of lines of code mixed with copy and styles, gets tangled in internal dependencies, and ends up producing a broken mess of half-written functions.

The problem here isn't weak algorithms, but a lack of project discipline. In real software development, no senior engineer dives headfirst into coding a project: first the idea is formulated, then it is broken down into logical stages, dependencies are agreed upon, and only after the plan is approved are tasks distributed to executors. That exact hierarchical model is implemented by the Idea Foundry pattern, deployed on top of the open-source Hermes Agent framework.

The monolithic prompt trap and the birth of Idea Foundry

The main vulnerability of monolithic requests is exponential growth of entropy. When a model tries to be a marketer, frontend developer, and QA tester at the same time in a single context window, its focus falls apart. Any minor mismatch at an early stage triggers an avalanche failure of the entire build.

The Idea Foundry pattern splits the process into two layers:

  • Upper layer (Project Manager Agent): a reasoning agent that doesn't write application code itself, acting instead as a thoughtful technical lead. It listens to the user, classifies business goals, and builds a directed acyclic graph (DAG) of tasks.
  • Lower layer (Worker Agents): specialized subagents (copywriter, frontend builder, integrator, QA), each of which receives an isolated task with clear acceptance criteria (Definition of Done).

Five phases of the pipeline: from idea to finished product

In Julian Goldie's experiment, the Idea Foundry pipeline was tested on building a landing page for the AI Profit Boardroom project. The entire procedure fit into five sequential phases:

  1. Capture: a human enters just one line into the dashboard: "Create a landing dashboard for AI Profit Boardroom that clearly shows business owners how automation attracts leads and saves time."
  2. Classify & Route: the Hermes manager agent takes a few seconds to determine the task profile (web development + B2B copywriting), selects the tech stack (Tailwind CSS, vanilla JavaScript, webhook integration), and estimates the required resources.
  3. Create Plan: the high-level goal is decomposed into four sprints with explicit dependencies: copy and offers first, then component layout, followed by form binding and a final audit.
  4. Human Approval: the critical fork. The agent pauses and shows the structured plan to the human, waiting for an explicit click on the "Approve" button.
  5. Forge: after the operator clicks, subagents start on their tickets in parallel while the manager monitors dependency completion.

Human-in-the-loop: why you can't remove humans from the forks

Many enthusiasts dream of full autonomy without human involvement (Zero-Human Loop). In practice, removing the operator from the planning loop leads to massive time waste: if the agent misinterprets the business goal at the start, all subsequent work by the subagents goes straight into the trash.

The Human Approval gate radically changes the economics of the process. A human spends 15 seconds glancing over the plan: if everything looks right, one click launches the pipeline; if something is off, a single short remark makes adjustments. In practical measurements, introducing the approval step cuts the rate of rework from 42% to less than 5%, while parallelizing work across specialized subagents reduces total implementation time by 2.4x.

Dispatcher implementation and executor coordination

Below is a Python implementation of the Idea Foundry dispatcher managing the planning, approval, and execution phases:

from dataclasses import dataclass
from typing import List, Dict
import time

@dataclass
class ProjectTask:
    id: str
    title: str
    assigned_worker: str
    dependencies: List[str]
    status: str = "pending"

class IdeaFoundryDispatcher:
    def __init__(self, project_name: str):
        self.project_name = project_name
        self.task_graph: List[ProjectTask] = []
        self.is_human_approved = False

    def build_plan_from_prompt(self, user_idea: str) -> List[ProjectTask]:
        print(f"[IDEA FOUNDRY] Analyzing idea: '{user_idea}'...")
        # Build task graph with dependency control
        self.task_graph = [
            ProjectTask("T1", "Craft compelling offer and structure", "CopywriterBot", []),
            ProjectTask("T2", "Responsive UI layout in Tailwind", "FrontendBot", ["T1"]),
            ProjectTask("T3", "Connect webhooks for lead capture", "BackendBot", ["T2"]),
            ProjectTask("T4", "Accessibility audit and cross-browser testing", "QABot", ["T3"])
        ]
        return self.task_graph

    def await_human_decision(self) -> bool:
        print("\n=== PROJECT PLAN GENERATED BY MANAGER AGENT ===")
        for task in self.task_graph:
            deps = f"(waits for {', '.join(task.dependencies)})" if task.dependencies else "(starts immediately)"
            print(f"- [{task.id}] {task.title} -> {task.assigned_worker} {deps}")
        print("==================================================")
        # Simulate human click in web UI
        self.is_human_approved = True
        print("[APPROVAL GATE] Plan confirmed by operator! Launching subagents...")
        return True

    def run_forge(self):
        if not self.is_human_approved:
            raise PermissionError("Launch blocked: human confirmation required!")
            
        completed_tasks = set()
        for task in self.task_graph:
            if all(dep in completed_tasks for dep in task.dependencies):
                print(f"[FORGE] Agent {task.assigned_worker} picked up task {task.id}...")
                time.sleep(0.4)
                task.status = "done"
                completed_tasks.add(task.id)
                print(f"[FORGE] Task {task.id} closed successfully.")
        print(f"\n[DONE] Project '{self.project_name}' successfully built and ready for delivery!")

Here is the YAML ticket specification manifest that the manager sends to the executors:

project: "AI-Profit-Boardroom"
ticket_id: "T2"
role: "FrontendBot"
inputs:
  copy_manifest: "artifacts/T1_copywriting.json"
requirements:
  framework: "HTML5 + Tailwind CSS CDN"
  responsive: true
  form_validation: true
definition_of_done:
  - "All buttons have interactive hover effects"
  - "Form blocks submission when fields are empty"
  - "No placeholder text remains"

Idea Foundry proves that the future of effective AI adoption lies not in trying to squeeze the impossible out of a single chat, but in sound engineering decomposition and carefully preserving human control at key decision forks.

Want a deep diveVotes help us choose what to break down in detail. This material has 0 votes.
Sources · 3