Skip to article
Agents Autonomous

Hermes

Understand the goal. Organize the work.

The AI agent that directs work in the illustrated Darkworks and Nox Infra system. Turns an operator's request into a plan, coordinates specialist agents, and keeps the result under review.

Client: BlackwellX ↗

AI Control & OrchestrationArchitecture concept
Hermes — project illustration
The operator's goalPlanning and coordinationA verified result

One operator, several kinds of work

Hermes coordinates specialist agents in the Darkworks and Nox Infra system. The operator describes a goal through one point of entry; Hermes interprets it, organizes a plan, assigns work, follows progress, and brings the result back for review. Its role covers the connections between research, product planning, engineering, review, and release.

Those connections carry decisions. Research may reveal that the original requirement misses the user's problem. Review may return a finding that reopens implementation. A change in priorities may leave completed work useful for a later version but unnecessary for the next deliverable. Hermes connects each change to the overall task so the operator can choose what happens next.

The general manual counterpart is a person collecting updates from contributors, remembering why a decision was made, and translating that decision into the next assignment. When several tasks depend on the same requirement, a short message to one contributor can leave the others following an outdated plan.

Hermes gives the operator a way to direct that work as a connected assignment. The useful result includes the state reached against the goal, the intermediate material worth retaining, and the decisions still required. A large amount of specialist activity is only useful if those contributions answer the same request.

Turning an ordinary request into working assignments

The input can be a business goal, product idea, problem description, specification, reference, feedback, or change in priorities. These inputs have different levels of detail. A specification may already define the expected behavior; a business goal may establish only the desired outcome and constraints. Hermes organizes what is known and identifies what must be resolved before dependent work can proceed.

Planning connects tasks to completion criteria and establishes their dependencies. Assignment adds the context a specialist needs and the expected output. A contributor investigating a question needs to know which decision the research will inform. A contributor implementing a change needs the agreed behavior and the material required to check it.

The architecture separates specialist responsibilities. Research investigates markets, users, and possible solutions. Product prepares requirements, the architectural approach, and the work breakdown. Engineering implements, tests, and fixes. Review checks quality and material risks. Deploy covers release, monitoring, and optimization. Hermes coordinates these contributions and compares the assembled output with the operator's goal.

A missing detail does not always prevent every task from starting. The relevant question is whether it affects a consequential choice or an independent part of the work. Hermes' coordination role includes returning specific questions to the operator while organizing work that can proceed within the known scope. The dependency determines what should wait.

This makes the plan more than a list of agent names. It explains why one result is needed before another action and what evidence will establish completion. That relationship is especially useful when the operator changes direction after work has begun: the coordinator has a basis for finding affected assignments.

Illustrative walkthrough: bring the first workflow forward

Consider the priority-change request used in the project materials: deliver the core user journey sooner, show what will remain outside the first version, and revise the plan. The following walkthrough is illustrative, not a reported operational episode. To make the coordination decisions concrete, suppose the work concerns an internal request service with a main intake journey and an additional reporting view.

In this example, the operator would want people to submit a request and let its owner inspect the relevant context before the reporting view was ready. Hermes would first need the current state of work. The key inputs would be the latest scope, the contributors' existing artifacts, the dependencies between them, and the criteria Review expected to use.

The current state could contain several different kinds of progress. A product description might be agreed while implementation was still underway. A report design might be complete without any working report. Review might have checked only an earlier version. The revised plan would need these distinctions because "done" would otherwise mean something different for each contributor.

The operator's request would identify a priority without resolving every scope choice. For instance, showing the owner the request's status might be essential to the core journey, even if that same status also appeared in the deferred reporting view. Removing everything associated with reporting could therefore damage the first workflow.

Hermes would need to bring that dependency back to the product decision. In the walkthrough, a useful question would be whether the first version must display the current status beside each request while leaving aggregate reporting for later. The operator could approve that narrower boundary or explain why the reporting view was necessary for the first useful release.

The decision would then have a concrete meaning for contributors. The first version would retain the information the owner needed to act on a request, while the separate reporting view would move outside the immediate deliverable. Any remaining uncertainty would stay attached to the affected work rather than becoming an assumption made independently by each specialist.

Propagating the scope change through dependencies

Continuing the same walkthrough, Hermes would revise the plan around the approved journey. Product would need to update the scope and completion criteria. Engineering would need to identify which unfinished work remained necessary and which work could stop. Review would need the same boundary before assessing whether the narrower implementation satisfied the request.

Completed material would also need a disposition. A finished reporting design could remain available for a later version without counting toward acceptance of the first workflow. Keeping it would avoid unnecessary recreation when reporting returned to the plan. Keeping its earlier assumptions visible would also prevent a future contributor from treating an old design as a current instruction.

Parallel work would depend on the revised agreement. Once the owner-facing behavior was settled, engineering and preparation of the relevant review checks might continue together. Work requiring another unresolved product choice would wait. Hermes would need to communicate the reason for that wait so the operator could distinguish a dependency from a contributor failing to make progress.

The revised delivery plan would show the next deliverable, deferred capabilities, open risks, and the next review point. A deadline request alone would not establish how much earlier the work could finish. Any timing assessment would depend on the remaining tasks and review needs after the scope change. The operator would receive a proposal grounded in that remaining work.

If later feedback changed the core journey again, the same plan would need another revision. The reason for the change would matter to the next contributor: restoring reporting because the owner could not make a required decision would be different from simply adding an optional feature back into the queue.

Review checks the revised goal against a specific result

Hermes' quality role connects the specialist result to the operator's task and arranges review. In the illustrative service, Review would need the updated criteria and the version being assessed. A finding based on the superseded reporting requirement would send Engineering toward work the operator had deliberately deferred.

The revised checks would still need to exercise the whole retained journey. If a person could submit a request but its owner could not inspect the necessary context, the narrower scope would remain incomplete. Deferring the reporting view would not remove the agreed obligations of intake and ownership. Scope reduction would change what was required, while acceptance would still depend on whether the remaining requirements worked.

A review finding could take different routes. A mismatch between the accepted requirement and the implementation would return to Engineering. An unresolved disagreement about what information the owner needed would return to Product and, where necessary, the operator. Hermes would coordinate that return so the contributor received the decision or correction needed for the next attempt.

Intermediate artifacts would remain useful without being mistaken for the final outcome. A specification would establish agreement about behavior. An implementation would establish that work had been produced. Review evidence would describe what had been checked. The final account would need to explain which state the assignment had reached and which limitations remained.

For this walkthrough, an operator asking for a revised plan could accept the plan itself as the requested result. An operator asking for the first working workflow would need the corresponding implementation and review outcome. Hermes' completion report would have to preserve that difference, even when both requests concerned the same service.

Status that tells the operator what to do next

The architecture includes progress updates, reports, alerts, and Approve / Adjust actions. Telegram is an entry point; Nox Infra also presents web and mobile interfaces. These interfaces give the operator access to the current work and to decisions that affect its direction.

A useful implementation of the status view would distinguish planned work, execution, blocked work, review, and completion. These are operating-model details rather than a confirmed list of interface states. Their purpose is practical: the operator needs to know whether the next action is to provide information, choose an option, or inspect a result.

In the ongoing scope-change example, a status update could show that the first journey had been revised, reporting was deferred, and the core journey was ready for review. The operator could open the result and inspect it against the agreed scope. A count of active contributors would provide much less help in deciding how to move the work forward.

Updates would also need to identify material changes since the previous decision. If the operator had already approved the narrower journey, the next report should explain whether work still followed that agreement. A newly discovered dependency would deserve attention because it might change scope or timing. Routine intermediate output could remain attached to its task for inspection.

Approve and Adjust would need to refer to an identifiable proposal or result. In this example, approval of the revised scope would settle what belonged in the next version. Keeping the decision's object clear would let the operator act without guessing which subsequent operations a brief response would permit.

Context and authority survive specialist handoffs

Nox Infra's shared context includes memory, artifacts, and history. These provide the material needed to continue work across contributors: an earlier decision, an existing output, and the sequence that explains the current task. Hermes uses that shared process to coordinate work without requiring the operator to reconstruct every handoff manually.

In the walkthrough, retained context would include why reporting was deferred and which status behavior remained essential. The useful memory would preserve the decision's scope. "Reporting deferred for the first version" would leave room to revisit it later; "reporting unnecessary" would change the meaning and could misdirect future planning.

Darkworks names GitHub, cloud services, databases, monitoring, analytics, and payments as integration categories. Those categories describe where connected work may occur. Each connection still needs its own permissions, and a task's authority must apply when another specialist receives it. Access to source material does not grant every operation available in the same service.

Critical actions require a human decision. Preparing release material is separate from authority to release it. In the request-service example, the operator could approve a product scope while leaving any change to the target environment subject to a later decision. Hermes would need to carry both the permitted work and the remaining decision boundary through the plan.

Assessing coordination through accepted work

The business use of Hermes is a coordinated result with fewer handoffs for the operator to reconstruct. Its contribution is most visible when a decision affects several specialists: the requirement changes once, and the next assignments and review basis need to reflect that same change. Measured Hermes performance has not been provided.

Evaluation should therefore follow the consequences of coordination. Lost requirements show where intent failed to reach a contributor. Waiting between stages shows where an input or decision arrived too late. Repeated work can reveal an outdated assignment or review against a superseded scope. Each measure needs the reason for the delay or repetition to identify what should improve.

Operator supervision time belongs in that evaluation. If the operator repeatedly has to restate that reporting was deferred, the system has failed to preserve an agreed boundary even if individual contributors finish their tasks. If a specific dependency question lets the operator settle the scope once, the coordination has produced a useful decision that downstream work can follow.

For the illustrated priority change, the team estimates around 45 minutes of operator time to state the change, review the revised plan and dependency questions, and approve it, against roughly 4 hours of collecting updates and rewriting assignments by hand: around 5× faster. This is a modeled estimate, not a measured episode.

A larger number of simultaneous agents does not establish better coordination. The more informative measures are the share of tasks reaching an accepted result, unnecessary repeat cycles, and the attention required to get there. For the next assignment, the record to inspect is the operator's goal, its approved revisions, and the evidence that the final result answered the latest agreement.