AI workflows you can read, test and audit.

risk = call_model(
  f"Classify the risk...\n{diff}",
  retries=3,            # policy buried in code
  timeout=45,
)
if "high" in risk.lower():   # parsing prose
    requests.post(HOOK, json={"risk": risk})
# where is the audit trail?
# what did run #482 actually do?
# can a reviewer read this as a process?

Policy is a declaration

retry, timeout, cache and fallback live on the agent, not scattered through logic.

Prompts are typed

Explicit signatures and composition, so lint catches the mistake before the run.

State is named

memory says what survives the next step, and where it is written down.

import { Diff } from "./review-types.mh"

agent Reviewer {
    command: "claude"
    args: ["-p", "${prompt}"]
    retry: { max_attempts: 2 }
    cache: { ttl: 1h, storage: "disk" }
}

prompt Triage(diff: string) {
    """
    Classify the risk of this change.
    Answer with low, medium or high.

    ${diff}
    """
}

memory Audit {
    type: "jsonl"
    path: ".mhl/audit.jsonl"
}

pipeline ReviewPullRequest {
    input diff: Diff
    var risk = ""

    step Classify timeout 45s {
        risk = Reviewer.run(prompt: Triage(diff: diff))
        Audit.append({ risk: risk, at: time.now() })
    }

    step FanOut {
        spawn a = Reviewer.run(prompt: "Review ${x}") for x in []
        wait a
    }

    step Escalate {
        if (risk == "high") {
            http.post("https://hooks.example.com/review", body: { risk: risk })
        }
    }
}

import Imports a shared type from another MHL file. agent What can be called, and under which limits: command, retry and cache are explicit; timeout is defined on the step. prompt A typed, reusable template. The instruction is source code, not a hidden string. memory State with a name and a shape: ephemeral, persistent JSON, or an append-only audit log. pipeline The contract: which inputs the flow requires, and which variables it keeps. step One unit of execution: call the capability, keep the value, record what happened. spawn · fan-out Starts one call per item; with an empty array, it creates zero handles and wait completes without work. if · integrations Deterministic branching and outbound calls — the program decides, not the model's prose. Full pipeline and step syntax →

$ mhl run review.mh --input diff="$(cat patch.diff)"

▸ step Classify   agent Reviewer   cache miss   1.84s
  ├ retry 0/2     tokens 1420 → 38
  └ risk = "high"
▸ step Escalate   http.post        200 OK       121ms
✔ ReviewPullRequest                             2.09s
  audit .mhl/audit.jsonl  +1 entry
  checkpoint .mhl/state/review-482.json

Before exposing a server

Bind deliberately, configure authentication for non-local use, choose a state directory for resumable runs, and review the permissions of every workflow.

Serving guide →

agent Echo {
    command: "echo"
    args: ["${prompt}"]
}

prompt Greeting(name: string) {
    "Hello, ${name}. Your first pipeline is running."
}

pipeline Hello {
    input name: string

    step Greet {
        var answer = Echo.run(prompt: Greeting(name: name))
        log(answer)
    }
}