CtrlK
BlogDocsLog inGet started
Tessl Logo
SkillPublic

hephaestus-network

Use when the user asks OpenClaw to staff a durable goal from registered Local, owner Cloud, and public Hub agents or teams. The active host LLM chooses the exact roster, which remains goal-bound until explicit completion.

Quality

70%

Does it follow best practices?

Run evals on this skill

Adds up to 20 points to the overall score

View guide
SecuritybySnyk

Low

Low-risk findings worth noting

Fix and improve this skill with Tessl

tessl review fix ./openclaw/skills/hephaestus-network/SKILL.md
SKILL.md
Quality
Evals
Security

Hephaestus Agent Workforce Network

The active host LLM staffs the task. Agentlas Core federates content menus from registered Local, owner Cloud, and public Hub inventory. No source and no deterministic layer is the decision-maker or a server-side LLM executor.

Source scopes are exact:

  • network: Local + Cloud + Hub;
  • local: registered Local packages only;
  • cloud: the signed-in owner's Cloud packages only;
  • hub: public Hub packages only.

Before an unpinned search uses the Local source, Core refreshes every active registered source folder and creates a new immutable release when its safe content snapshot changed. This is discovery freshness; a prepared or goal-bound roster remains pinned to its exact release. network reindex is a rebuildable card-cache operation and is not required to refresh a registered Local release. New folders still require explicit local-register.

Public demos and distribution proof use explicit hub scope. They must not use private Local/Cloud inventory as evidence of public availability.

Resolve the runner and sign in

Network can query owner Cloud and public Hub inventory, so establish the same saved Agentlas session before staffing:

RUNNER=""
for c in \
  "$HOME/.agentlas/runtime/current/bin/hephaestus" \
  ./bin/hephaestus
do [ -x "$c" ] && RUNNER="$c" && break; done
if [ -z "$RUNNER" ]; then
  for cache in \
    "$HOME/.claude/plugins/cache/agentlas-core-engine/hephaestus" \
    "$HOME/.codex/plugins/cache/agentlas-core-engine/hephaestus"; do
    newest="$(ls -d "$cache"/*/bin/hephaestus 2>/dev/null | sort -V | tail -1)"
    [ -n "$newest" ] && [ -x "$newest" ] && RUNNER="$newest" && break
  done
fi
if [ -n "$RUNNER" ] && [ "${HEPHAESTUS_AUTH_AUTOPOPUP:-1}" != "0" ]; then
  "$RUNNER" auth ensure >/dev/null 2>&1 || true
fi

The browser opens only when no reusable local sign-in exists. In CI or another headless environment, set HEPHAESTUS_AUTH_AUTOPOPUP=0.

Required MCP sequence

First confirm the typed tool menu contains workforce.preflight_work_order and that its _meta.protocolVersion is at least 2026-08-20.1. If the tool is absent, the host is still attached to a preflight-less runtime. Do not fall back to model-authoring the strict wire WorkOrder and do not retry the same invalid call. Return the machine-readable boundary workforce_protocol_upgrade_required; let the runtime's normal verified auto-update finish, then reload the host/MCP session. An explicit hephaestus hep-update remains an operator action, never an implicit skill side effect.

"Absent" must be proven against the host's real tool names, not a guessed spelling. Hosts rewrite MCP tool names: the server is hephaestus-network, and Codex, for example, exposes workforce.preflight_work_order as mcp__hephaestus_network__workforce_preflight_work_order (the dot becomes one underscore; the prefix is the server name, not agentlas). Before returning workforce_protocol_upgrade_required, search the tool menu for every name containing preflight_work_order and goal_context. If any match exists, the tool is present — call it. If other hephaestus-network tools (for example context_slice) are present but these two are not, report both facts; that is not proof of an old runtime. Measured 2026-09-24: a Codex session probed the invented mcp__agentlas__workforce__goal_context, found nothing, and halted staffing while runtime 1.2.49 was serving both tools.

Use the Agentlas Core Workforce contracts in this order:

workforce.preflight_work_order(taskBrief=..., roles=..., edges=...)
workforce.search_candidates(workOrderRef=..., sourceScope="network")
workforce.expand_candidates(selectionSessionId=..., candidates=[{slotId, candidateOrdinal}])
workforce.validate_selection(decision={selectionSessionId, decisionAuthor, assignments})
workforce.prepare_execution(selection={selectionSessionId}, federatedSelectionDigest=..., projectDir=..., goalId=activeGoalId?, fullDossier=false)
workforce.validate_execution_receipt(receipt=..., executionPlan=..., toolInventory=...)

Call these exact typed tools directly. Do not enumerate, serialize, print, or search the host's complete ALL_TOOLS registry: the sequence and tool names are already specified here, and dumping unrelated schemas spends context without improving staffing.

The source-internal workforce.fetch_runtime_bundle call is performed by Core from the pinned original source session/digest. The host must not call it directly or replace it with a slug/latest lookup.

The default search response is a projected decision menu. Preserve its source receipts and selectionSessionId, but do not echo that projection as federationResult; Core resolves and revalidates the full pinned result by session. The final receipt call is local, bounded, and read-only. It validates host-produced evidence and never executes workers or creates a receipt.

The current CLI equivalent is workforce search --scope network. A host adapter that does not yet expose typed sourceScope must report that wiring gap; it must not silently call public Hub-only search and label it Network. Do not call the legacy lexical router first. Do not turn install count, ratings, invocation history, source precedence, or a deterministic top score into the staffing decision. If a source is unavailable, preserve its finite failure receipt.

1. Perform job analysis

Act as the active top-level orchestrator. Convert the user's task into one compact semantic draft for workforce.preflight_work_order. Core compiles it into the exact redacted agentlas.workforce-work-order.v1, generates finite WorkOrder/slot/artifact identifiers, fills omitted empty arrays, pins the ontology version, validates the privacy boundary, and returns a one-hour workOrderRef. Keep raw local files, secrets, memory, and private prompt details on the host. Create one roles entry per materially distinct responsibility. Each role may identify:

  • semantic role/community and required skill or knowledge concepts, written as plain English phrases when no ontology id is obvious — Core normalizes them into schema-valid concept ids and reports every rewrite as normalizedConcepts. Only these semantic communities, roles, skills, and knowledge may narrow menu fit;
  • execution requirements such as required MCP/tool capabilities, runtime, language, modality, and required/forbidden authority. Include these only when the requested action genuinely needs host proof. They never filter, rank, or exclude semantic candidates; Core carries them into the ExecutionContext and the host validates them against its actual tool inventory, capability binding plan, permission policy, and invocation receipt after selection;
  • collaboration edges by 1-based role ordinal. An edge is a declaration of handoff, never a qualification requirement. Requiring an artifact almost no published agent declares does not narrow a menu, it empties it;
  • executable entity-kind constraints;
  • cardinality, criticality, and collaboration edges;
  • the minimum evidence level: declared, checked, demonstrated, or attested.

Do not create decorative roles. A single specialist is valid for a genuinely single-role task; a composite task should become a real temporary task force. Executable slots allow only agent or team; group is discovery-only until an authoritative group execution contract exists.

Omit unconstrained runtime, authority, language, and modality arrays. Never invent prefixed finite values such as language:ko or custom slot/artifact IDs; the draft schema exposes the finite values and Core owns mechanical IDs. Use the default candidate policy (2 minimum, 30 maximum per role) unless the task has a concrete recall reason to widen it. Protocol receipt verification is already an independent gate, so do not add a decorative verifier role merely to restate it.

The user never has to write the word goal or enable a goal mode. Before a new search, call workforce.goal_context for the current project. If an active binding is the same ongoing work, treat its goalId and roster as incumbent. Only create a new WorkOrder when no active binding covers the work or the incumbent has a real gap.

2. Retrieve the menu, then make the LLM decision

Before calling any remote source, call workforce.preflight_work_order. Its deterministic compiler and WorkOrder boundary cover every schema-declared string and structured identifier, including nested roles, skills, tools, authorities, artifacts, edges, runtime/language, and policy fields—not only prose fields. A path, personal/account identifier, credential URL, private concept identifier, or secret-like value returns only path/class repair evidence with hubCalls=0 and a null rejected-object digest; never trust a draft's prose, echo the rejected value, or compute/display a digest over rejected data. Ask Core for sourceScope="network" with the returned workOrderRef only after that boundary accepts. Do not echo the compiled WorkOrder. Each source returns a bounded shortlist by default; narrow it, then use workforce.expand_candidates only for the candidates worth a full-card comparison. Each source's complete menu remains pinned in Core; Core validates and unions them using canonical identity ordering. It performs no semantic rerank. Read the exact roles, skills, MCP tools, inputs/outputs, authority, eval evidence, communities, release version, package hash, content digest, source receipt, and provenance.

Source precedence is not ranking. It applies only when the same agentDefinitionId has verified identical lineage issuer/digest and the exact same release version, package hash, content digest, and entity kind at multiple sources. Then and only then shadow Local > Cloud > Hub. Similar names/slugs are never deduplicated. Missing lineage or different releases fail closed for that collided identity: Core quarantines the ambiguous definition and preserves unrelated Local/Cloud/Hub candidates with finite aggregate conflict evidence.

You, the active host LLM, choose the ideal roster. Consider complementary coverage and handoffs, not a scalar top-1 score. Return agentlas.workforce-selection.v1 with decisionAuthor.kind = "host_llm", the real host model id, exact slot/release assignments, graph edges, alternatives, and short reason codes. Some nondeterminism in final judgment is intentional; hard constraints are not.

If a required slot has inadequate coverage, use at most two same-host semantic WorkOrder refinements across the whole decision. A provisional Selection may request content expansion through requestExpansionForSlots; the adapter gives the host only aggregate slot/count/gap data, never candidate identities. Never fill a post with a semantically unrelated agent or repeat an exhausted request.

3. Validate and pin exact releases

Send the compact decision — selectionSessionId, decisionAuthor, and one assignments row per post naming the candidate by its menu candidateOrdinal with reason codes. Core resolves the pinned WorkOrder, federated CandidateSet and federation receipt from that session, fills the candidate-set digest and the arrays that are empty in a normal decision, and compiles the exact agentlas.workforce-selection.v1. Re-plan on rejection. The validator may reject constraints, cardinality, cycles, drift, out-of-menu releases, or a source-pin mismatch; it must never pick for you.

Use public reason codes such as reason:best-content-fit, reason:best-contract-fit, and reason:host-semantic-judgment, or an exact code from the selected candidate's pinned evidence. Invented reason vocabulary is rejected; omitting compact-decision reason codes uses reason:host-semantic-judgment.

Prepare the accepted choice with selection={selectionSessionId} plus the same response's federatedSelectionDigest. Core loads its own accepted wrapper and restores the Selection only when its exact digest matches. The unchanged accepted validation wrapper is also accepted under selection; the original exact Selection or the same compact decision remains supported. Never put a compact authoring decision under selection. If an older normalized receipt cannot restore the original bytes, resend the original decision or exact Selection. A changed or expired reference never chooses a replacement.

An accepted receipt can still carry unmetRequirementCount. That is not a rejection and Core will not choose for you, but it is not noise either: read selectionValidation.unmetRequirements, then either accept the gap on purpose or pick a different candidate. Never report an accepted validation as if nothing were unmet.

Do not send the merged CandidateSet to remote Hub/Cloud validation or preparation: it is not one of their source sessions. Core pins every assignment to the original source's selection session and candidate-set digest, then fetches the exact release/package/content claims from that source. Call Core federated preparation only after acceptance. Preparation must return agentlas.workforce-execution-plan.v5, status prepared, an exact preparationReceiptId, and an executionRoster whose release version, package hash, and content digest match the candidate set. It returns BYOM directiveBundle records. Every row must declare bundleDigestSchema=agentlas.workforce-runtime-bundle-digest.v4; recompute its canonical digest before execution and fail closed on mismatch. Digest values allow only Unicode-scalar strings, booleans, null, arrays, and ASCII-keyed objects; numbers, invalid keys, and __proto__/prototype/constructor fail closed. A row must also carry a nonblank top-level systemPrompt, instructions, or agentMd, a first-class digest-bound permissionPolicy, and an agent-null/team-authoritative executionGraph. Core owns policy projection; do not invent a missing canonical row policy or weaken an incomplete allowlist. Package fileRead allow/deny patterns scope files below the package root, not the project's files or the host's tool authority. Network, shell, MCP, and project access follow the current host's actual authorization. The plan's digest-bound executionContext must preserve every validated slot demand, WorkOrder/Selection edge and artifact kind, assignment and reason code. Missing or changed releases create unfilled posts; there is no silent substitution.

4. Bind the roster to the durable goal

Exact preparation must include projectDir and the incumbent goalId when one exists. Core rejects a preparation without a project and automatically binds every successful exact plan before it can be executed. On first contact, when the host has no durable Task/conversation id, Core derives a content-free stable id from the already-required WorkOrder id. Therefore “the user did not explicitly say goal” is never a valid reason to omit continuity. Later accepted preparations with the incumbent goalId append only newly recruited exact releases. Never replace or silently remove an incumbent release.

At the start of every later turn, read workforce.goal_context (the installed SessionStart/UserPromptSubmit hooks also project the same bounded context). Pass knownRevisions with the goalId -> rosterRevision pairs already in this conversation: unchanged goals come back as one line instead of a full roster, which is what makes a continuity read cheap enough to actually do every turn. Read pendingExecution in that response — those releases were prepared and never executed, and the session-end checkpoint reports the same fact to the user, so it cannot be quietly carried forward. The active host LLM must choose exactly one turn posture:

  • reuse: the bound roster plus local skills can handle this turn;
  • local-only: no bound worker invocation is useful for this turn;
  • recruit: a real role/tool/modality gap requires another Network cycle, followed by another additive workforce.bind_goal;
  • standby: no worker needs to execute, but the roster remains bound;
  • blocked: the goal cannot progress safely.

Record that content-free decision with workforce.record_goal_turn. A turn ending, session closing, runtime restarting, context compaction, or worker invocation completion must not release the roster.

Public Hub package calls are free. The host still supplies its own model, API keys, permissions, and runtime. No Hub day lease or per-call credit purchase is required. A roster remains bound until explicit goal completion.

standby means a durable roster binding available to later turns. It does not mean a continuously running model, process, socket, or background token burn. Only actual worker invocations accumulate their normal Memory Curator and Experience records.

Call workforce.complete_goal only after the user or authoritative host goal state explicitly marks the whole goal completed or cancelled. It requires explicitCompletion=true; completing one model turn is not a goal-completion signal.

5. Use the host's model and honor operator policy

Read hostModelPolicy from the current workforce.goal_context response. For inherit_host, launch native delegates without a model or effort override; the host supplies its current model and effort. An unknown model identifier is not by itself a reason to prevent native delegation. Do not invent a model ID.

Use the stage's role from model_role_for_stage: plan, planner, leader, manager-plan, nested-manager, verify, verifier, synthesize, synthesis, manager-synthesis, route, and clarify are orchestrator; build, execute, worker, delegate, and task are worker. An unknown stage uses the orchestrator role.

For allocation_required, advertise real live host sessions and call model.resolve_allocation for the invocation stage. Honor its exact resolved provider, model, session, and effort, and launch only when executionAllowed is true; do not bypass an operator pin, ceiling, or capability requirement. If the host cannot establish or apply the result, report the policy boundary rather than claiming it was met. If policy is invalid or the posture is absent, do not assume it is unrestricted: use the existing allocation path or report the boundary. Model pins and ceilings come only from the MCP server's operator policy, not task or tool arguments. A missing worker policy inherits orchestrator; orchestrator never falls through to worker.

A resolved allocation does not prove invocation. Record only observed usage in the later invocation/run receipt; strict receipt telemetry is separate from actual execution. Never claim an unobserved model or effort as fact.

6. Execute the real task force

Run the prepared roster through the current host runtime:

  1. planner/manager creates structured worker assignments;
  2. each selected worker runs in a distinct model invocation with its exact release directive and only the needed local grounding;
  3. workers emit explicit handoff artifacts;
  4. synthesis runs after dependencies complete;
  5. an independent verifier checks the requested result.

Use the current host's native delegation first: pass each exact prepared directive bundle to a distinct native sub-agent, consume its handoff, and verify the requested result. Codex, Claude Code, and other external MCP hosts do not need the independent Agentlas Terminal product to run these packages. Do not change the user's execution host to obtain a receipt.

When a prepared release is itself a Team, honor its authoritative manager/worker/synthesis graph; do not flatten it into one prompt. The host continues to enforce its actual permissions. A package manifest allowlist is not a per-worker project sandbox requirement. For host-mode policies, a missing package-specific sandbox or receipt exporter does not block native invocation. Preserve genuine explicit policy restrictions, exact release pins, and host denials; report a failed action without widening its authority. zero-tools requires an actually empty tool inventory; a residual primitive isolated by forced read-only/no-filesystem is no-authority-sandbox, not zero-tools.

Snapshot the just-in-time policy-filtered local tool menu as a private agentlas.workforce-tool-inventory.v1 artifact and give only that menu to the executor planner. Never send the snapshot to Hub. The host LLM, not Hub or a lexical rule, records the pair-scoped capabilityBindingPlan. Validate capability bindings before using the corresponding tools; unavailable inventory or receipt telemetry is an evidence gap, not a new host-admission gate. Every required tool capability maps to an exact snapshot entry and permitted tool. A package policy mentioning a tool is not inventory proof, and a required binding cannot run under no-authority enforcement.

Use the external-host transport only when native delegation is actually unavailable. Its absence does not establish that the current host cannot run the roster. With an explicitly selected, available host adapter, the resolved runner executes the exact cached goal:

"$RUNNER" workforce execute \
  --project <current-project> \
  --goal-id <goalBinding.goalId> \
  --adapter-argv-json '["/absolute/path/to/host-adapter"]'

Core loads the full bound preparation from its local store; do not reconstruct it from a projected prepare.v2 answer. Each adapter process receives one agentlas.workforce-host-executor-request.v1 JSON object on stdin and returns one correlated agentlas.workforce-host-executor-response.v1 JSON object on stdout. The complete request, response, artifact, and refusal contract lives in the installed engine's agentlas_cloud/workforce/host_executor.py. Core orders distinct orchestrator, planner, workers, synthesis, and verifier calls, verifies artifact handoffs, and returns a receipt only after strict validation passes.

The adapter owns actual model invocation and measured policy enforcement; the command does not install an adapter or grant permissions. Check native host execution and existing adapters, then resolve a missing adapter with agentlas_resolve_plugins. Creating an adapter within already authorized work must use this provider-neutral contract outside Core. A model-only invocation can use an actually empty tool menu when no required capability binding needs tools; a prompt promise or a CLI flag with residual authority is not isolation. If a worker genuinely cannot be invoked, report its observed failure and the remaining work; continue other authorized host work. Missing receipt telemetry alone is not that failure. A route id, bundle id, process exit code, or prose that imitates several roles is not execution proof.

Preparation is not delivery. A turn that pinned a roster and produced no worker output has not answered the user's request, and the session-end checkpoint says so in the user's own view. Either run the roster and record the turn with workforce.record_goal_turn, or tell the user plainly that the team is prepared but not executed and what remains.

7. Truthful receipts

Receipt validation follows execution and never grants permissions or blocks the next authorized host action or turn. Preserve real native invocation IDs, exact package hashes, tool/action records, and handoffs even if the host cannot export the strict receipt. Report that receipt validation as unverified; do not call an actually executed worker merely prepared. Never fabricate telemetry or claim accepted validation when the validator rejected it.

When the host exports the required telemetry, retain one joined agentlas.workforce-execution-receipt.v2 joined to the exact v5 plan containing:

  • selection and preparation receipt ids;
  • orchestrator and planner model/invocation ids;
  • planner.parseSuccess, planner.fallbackUsed, toolInventoryDigest, and capabilityBindingPlanDigest;
  • every roster row's exact release/package/content/bundle/policy/graph digests, capability bindings, and handoff artifact refs;
  • either one real direct invocation or a nested receipt proving manager-plan parse/no-fallback, exact declared workers in graph order, and manager-synthesis; never fabricate one aggregate team invocation;
  • every actual model/provider/runtime, requested/applied effort with evidence, globally unique invocation id, and permission-enforcement evidence whose exact granted tool ids and inventory digest match the binding plan;
  • synthesis and verifier invocation ids and verifier verdict.

Never report the requested task complete when its result verification did not pass. Missing strict receipt fields remain an explicit evidence limitation, separate from observed native execution and verified task artifacts. In the user-facing summary, name the actual workers and distinguish selected, prepared, executed, and strict receipt validation.

Repository

agentlas-ai/Agentlas-OS

Path

openclaw/skills/hephaestus-network/SKILL.md

Last updated
First committed

Also appears in

agentlas-ai/Agentlas-OS
In sync

since Nov 2, 2026

agentlas-ai/Agentlas-OS
In sync

since Nov 2, 2026

agentlas-ai/Agentlas-OS
In sync

since Oct 19, 2026

agentlas-ai/Agentlas-OS
In sync

since Aug 17, 2026

Is this your skill?

If you maintain this skill, you can claim it as your own. Once claimed, you can manage eval scenarios, bundle related skills, attach documentation or rules, and ensure cross-agent compatibility.