MoH — Typed DAG Scheduling with Heterogeneous Executors

MoH is a typed DAG scheduling architecture with heterogeneous executors. Its unit of composition is a work contract — a typed description of what's needed, what authority is granted, and what acceptance criteria must pass — not a token stream or a gated routing decision.

The architecture routes between components of fundamentally different kinds — deterministic local execution, stateful analysis, and external research — whose outputs (file diffs, analytical decisions, and evidence bundles) cannot be averaged, blended, or gated like neural logits. The correct operation is decomposition into a typed DAG, not classification to a single expert.

MoH stands on solved ground. The following prior art is explicitly acknowledged:

MoH is not a single system. It is three distinct layers that should be built and reasoned about independently:

The three current harnesses are roles, not kinds. The architecture routes on declared capabilities + authority, not on identity. If pi gains network access, or Hermes gains a file-write capability, the topology changes — and that's fine, as long as capability manifests are explicit.

A core finding from the Iteration 3 review: join() was doing double duty. It was both "combine data" and "apply effects." These are separate operations with separate failure modes.

MoH defines a small type algebra with five composition operations:

Key rule: assemble_inputs, chain, attach, and wrap are compositions — they combine data without side effects. apply is a commit — it mutates workspace state. The runtime must distinguish these and require confirmation gates on commits. Homogeneous merge is intentionally absent: four harvest receipts share an envelope but are semantically incommensurable; each source must be handled as a named input.

The following issues were identified during Iteration 3 review (August 2026). They are ranked by remediation priority.

P0 — Ship-blocking

P1 — Design-level

P2 — Nice to have

The v0 is a deterministic, read-only revenue-alert graph. No autonomous mutation. No LLM planner. No multi-agent fan-out. No ad campaign pausing.

v0 contract:

• Wrap each existing harvester in an envelope (start/end timestamps, row counts, max source timestamp, error class)
• Emit a typed receipt for each harvest, not raw stdout
• Required-source failure produces degraded — never silently zero
• compute_metrics reads typed receipts, not raw stdout
• Telegram/console output is idempotent (stable occurrence key: condition_id + entity_id + period; rule_version is evaluation metadata, not part of dedup identity)
• All nodes emit strict JSON on stdout, human text on stderr
• Secrets loaded from environment, not embedded in source

v0 nodes (fixed catalog — no LLM planner):

v0 non-goals:

• No autonomous campaign mutation or pausing
• No dynamic LLM planner — static plan templates only
• No multi-agent synthesis — report is a direct composition of typed receipts
• No compensation or rollback — stop() records dirty workspace but doesn't clean it
• No dynamic graph expansion — all nodes known at declaration time

v0 falsifiable success criteria:

• 10+ successful fixture runs with schema-valid outputs
• All source and node failures visible (no silent zero)
• Reproducible audit reports from versioned artifacts
• Zero duplicate notifications/effects in injected retry/crash tests
• No claim of success without verified postconditions or complete provenance
• p95 runtime and cost tracked per node type

The smallest experiment that can falsify or support the MoH thesis: one graph where unlike outputs must genuinely compose.

v0.5 falsifiable criteria:

• Both harnesses invoked through same execution envelope without pretending outputs are identical
• compose preserves provenance to each input artifact
• At least one intentionally conflicting/mismatched input is represented explicitly, not dropped
• A degraded or failed input propagates via sticky degradation rule
• Same fixture and versions produce reproducible structural result
• Single-harness baseline recorded for latency, cost, failure rate
• Commit blocked when proposed_change status ≠ ok

If this cannot be implemented without ad hoc exceptions, the current contract design is falsified.

Default recommendation: adopt for execution, own the semantic types. Use existing orchestrators for mature mechanics. Focus bespoke engineering on the MoH-specific layer: envelope/receipt type system, artifact provenance, capability declarations, harness adapters, compose semantics, and structural checks.

Temporal is the stronger candidate for durable, long-running, retryable workflows with Saga compensation. Dagster is stronger where assets, lineage, schedules, and typed op I/O dominate. A thin local adapter is useful for development and offline tests.

Constraints that justify a bespoke Layer 2:

• Must run local-first with no daemon or service dependency
• Must operate offline or in sovereign/air-gapped environments
• Must avoid hosted control-plane cost or data egress
• Must have substantially smaller deployment footprint than Temporal/Dagster
• Must support file-based deterministic replay without a service runtime

Each claimed constraint needs a test. Run v0.5 in a disconnected environment, measure deployment footprint, demonstrate an artifact type that cannot be represented as an activity/op without loss. Do not build full Layer 2 before this decision is validated.

The thin waist of the system. Every invocation uses one common envelope and returns one typed receipt.

Invocation envelope:

Return receipt:

This iteration incorporated structured reviews from all three harnesses plus an external critic. Key conclusions:

• Thin waist: stable envelope format, capability manifests, typed receipts. The meta-harness doesn't grow its own agent — it stays a control plane.
• Least privilege: every node gets scoped authority and a short-lived context. pi can't do research, Hermes can't touch files.
• Lazy activation: start Hermes/Prime Agent only when a graph node requires them. Don't keep all three running.
• Explicit policy: routing rules, retry policies, confirmation gates, and conflict resolution live in declarative config, not in agent prompts.
• Streaming artifacts: pass snapshots, diffs, and evidence references — not giant context dumps.
• Audit trace, not deterministic replay: event log reconstructs what was decided, not the decision itself. Non-hermetic nodes are labeled.
• Human gates: require confirmation before irreversible mutation or low-confidence routing decisions.
• Fail closed: missing provenance, type mismatch, budget exhaustion, failed checks — stop the graph.
• Bounded autonomy: time, calls, depth, and repair iterations are hard limits, not suggestions.
• Fast path always: if the task fits ≤2 pi nodes, skip the planner entirely. Zero overhead for simple work.
• Layer 2 structural only: Runtime checks validate schema, status, hashes, dedup keys, provenance links, and artifact existence. Citation quality, evidence support, contradiction resolution, and alert-basis judgment are Layer 3 graph nodes — never hidden in the control plane.

• Calculus — Contract boundaries
• Vannevar Bush — Memex, associative trails
• Previous version of this page — Iteration 2 "Not MoE" framing