Commands are Gestures

Documentation Index

Fetch the complete documentation index at: https://docs.mirage.strukto.ai/llms.txt

Use this file to discover all available pages before exploring further.

​

Gestures Sit On Top Of Fingers

Fingers are the primitive ops, read, readdir, stat, write. FUSE is the infrastructure that makes those fingers available to every process on the host. Gestures are what Mirage builds on top: the commands an agent actually names. cat, grep, ls, head, tail, cp, mv, jq, awk, sed, each is a gesture. A gesture is a single coordinated motion composed from one or more fingers, with a name the Brain can call directly.

​

The Layered Picture

The fundamental layer is small on purpose. A handful of fingers plus a FUSE mount is all a backend needs to become part of Mirage. Every gesture in the catalog then works against that backend automatically, because gestures talk to fingers, not to backend SDKs.

​

Why Call Them Gestures

A gesture is one coordinated motion. That is the right size for cat (read a path), cp (move bytes from A to B), or grep (read-and-filter). Each is a single recognizable move the Hand performs, not a plan, not a workflow, just one gesture. The word also keeps the anatomical metaphor coherent. Fingers make gestures. Hands express themselves through sequences of gestures. The vocabulary stays inside one register.

​

Gestures Versus Skills

Mirage gestures are deliberately atomic. They correspond to the Unix command tradition: small, composable, one job per gesture. Skills, as used by Anthropic Agent Skills and the broader agent-skill open standard, are a higher-level unit. A skill bundles instructions, scripts, and resources an agent can load to perform a complex task end to end: “format this spreadsheet,” “write a professional letter,” “analyze this dataset.” Skills compose many gestures (plus reasoning, plus external knowledge) into a workflow. A useful mental model: gestures are what the Hand can do; skills are what the Brain has learned to do with sequences of gestures. Mirage owns the gesture layer. Skill-level composition is the agent harness’s job. See Anthropic’s engineering post on Agent Skills for more on the skill concept.

​

Adding A Gesture

A new gesture is a registered function that receives resolved paths and arguments, uses fingers to read or write, and returns a byte stream. See Commands for the dispatch model and Command Spec for how a gesture declares its flags and operands. Because every gesture is built on fingers, adding one does not require resource-specific code. It works against every backend that implements the finger set.

​

Why The Split Matters

Splitting Fingers (fundamental) from Gestures (composed) is what lets Mirage scale:

• Backends implement fingers. They do not need to know any gesture exists.
• Gestures compose fingers. They do not need to know any backend exists.
• New backend: every existing gesture works automatically.
• New gesture: every existing backend is already a viable target.

This is the concrete mechanism behind Mirage’s N + M promise. Fingers are the small M-side interface every backend speaks; gestures are the N-side catalog the agent draws from. The catalog grows without churning the backends, and the backends grow without changing the catalog.

​

Handshakes: Gestures Across Two Resources

When a gesture reaches across two resources, cp /s3/a /gdrive/b, diff /ram/a /disk/b, cat /s3/a /github/b, it becomes a Handshake. Still a gesture, but one the Hand performs by using two fingers on two different Eyes at once. The dispatcher handles the coordination; see the dedicated page for how.

​

Related

• Fingers, the primitive gestures’ building blocks.
• Handshakes, gestures that cross two resources.
• Commands, the dispatch model for registering and resolving gestures.
• Command Spec, how a gesture declares its flags and operands.