unhardcoded vs workflow & agent builders.
They own the graph; we own where each step's model decision lives. Vellum, LangGraph, n8n, and Dify orchestrate the flow — but the per-step model is pinned in the node. unhardcoded moves that choice into a policy you change without redeploying, and traces every decision.
unhardcoded vs Vellum · LangGraph · n8n · Dify
Same flow — different place for the model decision.
A builder lays out the steps and ships the app. The question is where each step's model is chosen: pinned in the node, or sent as policy with the call. Different jobs — they stack.
| unhardcoded | Workflow / agent builders | |
|---|---|---|
| Where the model is decided | Sent with the call as policy | Pinned in the node |
| Changing the choice | Edit the policy, no redeploy | Rewire the node and ship |
| Which model runs | Cheapest that clears your rules | The one you wired in |
| Quality floor | Enforced per call, fails loud | Eval suites, no runtime gate |
| Decision audit | Replayable by fingerprint | Run logs for the flow |
A fair, side-by-side read; both run over your own provider keys. Cost figures on this page are illustrative; the quality floor is the catalog field bench_intelligence, a 0..1 score. See the full lineup on the compare hub.
Builders are good at the graph.
Vellum, LangGraph, n8n, and Dify are credible tools for the orchestration itself — visual or code canvases for steps, branches, and human-in-the-loop, plus prompt versioning, evals, integrations, and a deployable endpoint. That scaffolding is their core job, and a good one. What they don't make explicit is the per-step model choice: it's wired into each node, and changing it means editing the graph and shipping again.
The model decision becomes policy, not wiring.
unhardcoded isn't a builder — it's the runtime policy layer inside an LLM node. The policy travels with the request: your backend sends a policy_ir with the call, and the router picks the cheapest model that clears your rules over your own provider keys. Change the rule, and every step routes differently on the next call — no graph edit, no redeploy.
An explicit choice
Instead of a model string baked into the node, each step states the constraint and lets the cheapest passing model win — gemini-3.5-flash at $0.018 when it clears the floor, a stronger model only where the rules demand it.
A quality floor that fails loud
The floor is the catalog field bench_intelligence, a 0..1 score, e.g. ["cmp","bench_intelligence","ge",0.5]: deepseek-v4-flash (0.42) is filtered out, gemini-3.5-flash (0.54) passes. No silent downgrade — if nothing clears, the call fails instead of guessing.
A trace you can replay
The proof is the receipt: candidates, the winner and why, which rule rejected the rest, the fallback path, and the fingerprint 301140696-1054914287 (sigma-pol/v1) to replay months later. See a trace →
Keep your builder. Route each node through unhardcoded.
These aren't substitutes — they're complementary. unhardcoded speaks the OpenAI-compatible API, so it sits underneath the builder you already use: keep the graph where it is, point each LLM node at unhardcoded, and the model decision moves into policy.
What you get by stacking them
- Cheapest passing model per node — each step routes on its own policy; classify on
gemini-3.5-flash, synthesize onclaude-sonnet-4-6, guard onclaude-opus-4-8only where it earns its cost. - Per-step fallback — when a node's model errors or times out, it advances to the next passing candidate without restarting the flow or redeploying.
- One audit you can replay — every node's decision lands in the trace, keyed by fingerprint, so a flow run is reviewable months later.
Prefer to express the whole task in unhardcoded? flow_ir is a bounded DAG where each step carries its own policy — one stitched trace, billed as one run up to 5 nodes. It composes policies; it doesn't replace your builder.
Build the graph your way. Route every node by policy.
Keep the workflow or agent builder you like, and let unhardcoded pick the cheapest passing model for each step — with per-step fallback and a replayable trace. Join the waitlist to put the model decision layer under your flows.