Use when the user types $hephaestus-network, /hep-network, or /agentlas-network, mentions @Hephaestus, or asks Agentlas to staff a durable goal from registered Local, owner Cloud, and public Hub agents or teams. The active host LLM staffs each turn; the exact roster remains goal-bound until explicit completion.
74%
Does it follow best practices?
Run evals on this skill
Adds up to 20 points to the overall score
Low
Low-risk findings worth noting
Fix and improve this skill with Tessl
tessl review fix ./codex/plugins/agentlas-core-engine-meta-agent/skills/hephaestus-network/SKILL.mdThe canonical home for this skill is hephaestus-network in agentlas-ai/Agentlas-OS
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.
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
fiThe browser opens only when no reusable local sign-in exists. In CI or another
headless environment, set HEPHAESTUS_AUTH_AUTOPOPUP=0.
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.
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:
normalizedConcepts.
Only these semantic communities, roles, skills, and knowledge may narrow menu
fit;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.
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.
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.
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.
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.
Run the prepared roster through the current host runtime:
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.
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:
planner.parseSuccess, planner.fallbackUsed, toolInventoryDigest, and
capabilityBindingPlanDigest;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.
agentlas-ai/Agentlas-OS
e68fc35
Canonical home
since Jul 28, 2026
Also appears in
since Nov 2, 2026
since Nov 2, 2026
since Aug 17, 2026
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.