What a mission is

A mission is a way of doing something, written down once, that an agent follows every time instead of improvising. It is the unit you build, test, move between machines and hand to other people’s software. Everything else on these pages — procedures, framework runners, the front door — is a mission in one of its shapes.

Mission and procedure are the same thing. The CLI and log lines say mission (--mission, runs ONE mission (sealed)); some pages say procedure.

What it is made of

A mission is a memory — a folder the agent can search — with a fixed layout:

part	file	what it does
the map	`sources/_flowchart.md`	which card handles which kind of question
the cards	`sources/<card-id>.md`, one each	the steps for one kind of question
the fence	`sources/_manifest.md`	the only memories, skills and commands it may use
its files (optional)	beside `sources/`, e.g. `runner.py`	files the mission carries and uses — copied into each turn’s folder
its command set (optional)	sealed in the agent, not in the folder	the exact commands it may run, each pinned to a file’s sha256
the index	`chunks.jsonl`, `vectors.bin`, `terms.*`, `manifest.json`	built from the above so the agent can search it

CrewAI_v1_Runner/                 ~/.hexaeight-harness/memories/<mission>
  sources/
    _flowchart.md                 the map
    _manifest.md                  the fence
    ask-runner.md                 a card
  runner.py                       a file the mission carries
  chunks.jsonl  vectors.bin  …    the index

The command set is deliberately not in the folder. Approvals belong to an identity; a mission you download never brings its own permission to run anything.

The two kinds

	Guided	Direct
a card says	steps: search this, read that, decide, answer	`mode: direct` — one command
who decides	the agent’s model walks the map and the card’s steps	nobody: every message goes to the command
the model	the harness’s model reasons through the card	the harness makes no model call; whatever the command runs may call one
typical use	research, runbooks, compliance checks	a framework (CrewAI, LangGraph, …) that does the work itself
cards	as many as the method needs	exactly one

A direct card:

## card: ask-runner
id:            ask-runner
mode:          direct
direct_input:  question.txt
direct_run:    "python3 runner.py --question-file question.txt"
resources:
  files:       [runner.py]
  commands:    ["python3 runner.py --question-file question.txt"]

The harness writes the message to question.txt — the message never reaches a shell — runs the one command through the command gate, and returns what it printed, unchanged. Every framework mission uses this same card; only runner.py differs.

Where it lives, and its life

 build            ingest              run                 move                 serve
 ─────            ──────              ───                 ────                 ─────
 workspace   →    mission memory  →   workspace:      →   export a .zip   →    a runner, sealed to
 "mission"        (map, cards,        runmission          enable <fw> /        ONE mission, for
 session          fence, index)       engine              agskill-import       outside callers

Build. In the workspace, a session on a mission engine: you describe the method, it becomes cards beside the conversation, you correct it in the same conversation.

Ingest. Writes the map, the cards and the fence into the mission memory and indexes them. Ingest is the complete set (workspace r35 and later): a card you removed is dropped from the mission and from its index — re-ingesting after deleting a card leaves no trace of it being found.

Run. In the workspace, on the runmission engine, pick the mission. Each turn gets its own working folder, and the mission’s files (a runner.py, say) are copied into it fresh from the mission — a copy left behind by an earlier turn is replaced by the approved one.

Move. Export it as a bundle and import it elsewhere:

hexaeight-activate agskill-export --mission My_Mission --out mission-My_Mission.zip
hexaeight-activate agskill-import --in mission-My_Mission.zip

A bundle carries the map, the cards, the fence and the mission’s files. It does not carry the corpora it searches, and it never carries permission to run a command — the command set is re-created on the receiving agent (cmdset seal, which enable does for you). For a published framework mission, hexaeight-activate enable <framework> does the whole move: it downloads the bundle, verifies its sha256, installs the sources and files, builds the index on your machine, and has your agent seal the one command.

Serve. A runner is a second agent sealed to one mission. Outside callers choose the question, never the mission. See Other software calling it.

What keeps it safe, step by step

at	what holds
the card	a direct card’s message goes to a file, never onto a command line
the fence	the mission may use only what `_manifest.md` lists
the command set	a command runs only if it is in the mission’s sealed set, and the file it names still has the sha256 that was approved — edit one byte and it will not run until sealed again
the turn	runs jailed: the agent’s identity folder is masked, each turn has its own folder
the runner	sealed to one mission; a caller cannot choose another, add priming, or name a different card
the runner’s store	a runner sees only its own mission until you export a memory into it (`runner-memory --share`)

The approval covers the launch, not what the launched program does next. A command set pins which file runs. Anything that file starts itself is not approved separately — keep runners free of shell tools, and review the file before you seal it.

Words you will meet


`runmission`	the engine that runs missions in the workspace
`missionrun-external`	a runner’s engine, sealed to one mission
`cmdset seal`	the agent command that records one approved command, pinned to a file’s sha256
`enable <framework>`	install a published framework mission, its environment, and its sealed command, in one step
`runner-memory`	decide which memories a runner can see
mission files	files beside `sources/` that the mission carries and each turn receives

A procedure it follows — the cards and the map, field by field
Your framework already works — direct missions with CrewAI, LangGraph, PydanticAI and Agno
Other software calling it — a runner, and what it can see