Design the system before you build the agent.

Prompts, retrieval, tools, loops, and application code quickly become the architecture by accident. A final answer cannot show which boundaries were intentional—or which decisions disappeared inside one agent.

Do not let one agent become the architecture.

CMG stays domain-free. The core vocabulary is deliberately small enough to investigate, compose, and verify.

Start with a structured examination, not an automatic generator. The builder decides which boundaries matter; CMG makes those decisions executable and inspectable.

Method boundary / CMG does not scan a product idea automatically. The builder projects the problem into transforms, connections, evaluation, and feedback; CMG supplies the executable object.

Use the same evidence-synthesis problem to inspect four candidate patterns. These are architecture hypotheses—not performance claims. Signals arrive only after execution.

The architecture definition and the executed graph are the same object. The terminal view derives from that graph and its completed trace—there is no separately maintained whiteboard diagram.

Graph
[Reading] ─┬─▶ [Physics]   ─┐
           └─▶ [Empirical] ─┴─▶ [Reconcile]

Run
  physics       40 → 125
  empirical     40 → 145
  reconcile     [125,145] → 20
  evaluation    fail
  feedback      retry

A transform can return a valid value while the relation between transforms is wrong. Record the relation you expect, then inspect whether the run preserved it.

The graph makes relations inspectable. The evaluator decides which relations matter.

Architecture sketches make tradeoffs discussable; executed traces make them measurable. Missing evidence stays missing—it is never replaced with a confident score.

You should not need to learn the theory before you can inspect the system.

TypeScript and Python capabilities ship at parity. This concise specimen is adapted from the repository’s core pipeline and terminal APIs.

import { createModelGraph, createTransform } from "@composable-model-graph/core";
import { renderRun } from "@composable-model-graph/terminal";

const trim = createTransform<string, string>({
  id: "trim", name: "Trim",
  run: (input) => input.trim(),
});
const words = createTransform<string, string[]>({
  id: "words", name: "Split words",
  run: (input) => input.toLowerCase().split(/\s+/),
});
const graph = createModelGraph({
  id: "pipeline", name: "Core pipeline",
  transforms: [trim, words],
});
const run = await graph.run("  Hello Model Graph  ");
console.log(renderRun(graph, run));

from composable_model_graph import (
    create_model_graph, create_transform,
)
from composable_model_graph.terminal import render_run

trim = create_transform(
    "trim", "Trim", lambda text, ctx: text.strip()
)
words = create_transform(
    "words", "Split words",
    lambda text, ctx: text.lower().split(),
)
graph = create_model_graph(
    "pipeline", "Core pipeline", [trim, words]
)
run = graph.run("  Hello Model Graph  ")
print(render_run(graph, run))