Deterministic AI orchestration — agents that run the same way every time
ForgeShift turns probabilistic agents into repeatable infrastructure for software development. A fat platform holds every workflow, hook, and state for software development — so the agent stays thin, disposable, and governed. Same input, same path, every run.
Thin agent. Fat platform. Thin skill.
Determinism comes from where you put the intelligence. Agents are disposable and hold nothing. The platform holds all persistent state, knowledge, and enforcement. Skills are thin routes into a codified library.
Thin Agent
Spawned, scoped, and discarded. Holds no memory and makes no rules — it only executes the workflow it was handed. Disposable by design.
Fat Platform
The source of truth. State, knowledge, hooks, and codified workflows live here — versioned, enforced, and replayable. The platform is what makes runs deterministic.
Thin Skill
A routing skeleton, not a knowledge base. Skills point to the Tier-2 library where the real domain logic is codified once and reused everywhere.
Five rules the platform enforces
Not guidelines. Not best-effort. Every one is wired into hooks, scripts, and gates that run on every tool call.
Platform over improvisation
If a protocol, hook, or script exists for the task, it gets used. No reinvention per run.
Hooks govern every tool call
Pre- and post-tool hooks are deterministic enforcement layers, not suggestions.
Agents are disposable; state is not
All persistent state lives on the platform. Kill an agent at any time — nothing is lost.
Context is a budget, not a workspace
Large corpora and multi-file work fan out to background agents, keeping the main context lean.
Roles are enforced, not assumed
Orchestrators coordinate; workers implement. Every BRC pair ships a PR plus a review agent.
Every task walks the same six phases
Routed at the start, gated in the middle, verified at the end. No phase is skipped, combined, or improvised — the router decides the path, the hooks hold the line.
Setup
Workflow registration, triage, and git validation. The path is decided — and the run recorded — before any work begins.
Discovery
All research runs through background agents on a research protocol. Read-only — structure and blast radius, before a line changes.
Design
Blueprint, architecture documentation and implementation plan with a dependency graph and task queue, approved at a human gate before build.
Build
Built-in debate where every task gets a development and QA worker pair as background agents. Each completed pair ships an incremental PR and a review agent.
Verify
Compliance checks, the full test suite, and coverage verification run before anything is allowed to ship.
Deliver
Incremental PRs merged, Layer 3 multi-select, and the outcome recorded back to the platform for the next run.
The machinery behind every deterministic run
Four primitives carry the guarantees. None of them live in the agent — all of them survive it.
Enforcement hooks
PreToolUse and PostToolUse hooks intercept every call, blocking off-policy actions deterministically — the agent cannot route around them.
Persistent state
Sessions, handoffs, and knowledge live on the platform — not in a context window. Resume, replay, or audit any run after the fact.
Background workers
Build–Review–Critique pairs run in isolated background contexts, fan out in parallel, and report back without bloating the orchestrator.
Code-graph nav
A queryable graph answers blast-radius, callers, and importers before edits — so plans are grounded in the real shape of the code.
Best practices wired into an orchestration system
Every principle above is enforced in our own orchestrator — the deterministic platform. Here's the concrete mechanism that makes each one hold, not hope.
Curate the context; don't hoard it
Skills and knowledge load only when a task needs them, finished work is compacted into saved state, and heavy jobs run in separate agents — so the working context stays small and focused.
Rules that must hold are code, not prose
Anything the system must always do is enforced by a script that runs automatically — not written as a guideline in a document the model is free to skip.
A gate checks every action before it runs
Before each tool call a deterministic check runs and can physically block a disallowed action. It doesn't ask the model to comply — it removes the option.
Thresholds are exact values, not adjectives
Every gate condition and limit is a concrete number in a config file. A number gets obeyed; a sentence about 'warnings' gets interpreted.
Every task walks the same fixed stages
Work always flows plan → build → verify → ship, and each stage has an exit gate that must pass before the next begins. Testing is structural, not optional.
Disposable workers; the platform holds the memory
Workers are spawned to do one task and thrown away — for a build, a dev worker and a reviewer worker check the same task, then vanish. All durable state and knowledge lives in the platform, not the worker.
Secrets that never touch disk
Credentials are pulled from a vault the moment a command runs and passed straight into that process's memory — never written to a file, never committed to the repo, and gone the instant the command exits.
No .env file. Nothing on disk. Nothing in git.
Stop hoping your agents behave. Make them.
Put the intelligence in the platform, keep the agent thin, and ship runs you can replay, audit, and trust.
Book a discovery call →Questions about deterministic orchestration
Deterministic AI orchestration is an approach where the intelligence, rules, and state live in a platform around the AI agent rather than in the agent itself. The agent stays thin and disposable while hooks, phases, and configuration enforce the same path on every run — so the same input produces the same, auditable outcome.
It means the AI agent is kept minimal and short-lived — it holds no memory and makes no rules — while a 'fat platform' holds all persistent state, knowledge, and enforcement. Because the durable intelligence lives in the platform, any agent can be stopped or replaced without losing work.
Rules that must always hold are enforced by hooks — deterministic scripts that run before and after every tool call and can physically block a disallowed action. Enforcement lives outside the model, so compliance isn't requested, it's guaranteed.
Every task walks the same six phases: Setup, Discovery, Design, Build, Verify, and Deliver. Each phase has an exit gate that must pass before the next begins, so testing and review are structural, not optional.
A normal agent carries its own context and behaves probabilistically, so results drift between runs. Deterministic orchestration moves the intelligence into the platform — configuration, hooks, phases, and state — so runs are repeatable, replayable, and auditable.
Teams that need AI agents to produce reliable, repeatable software-development outcomes rather than one-off results — where auditability, governance, and consistent behavior matter more than raw model capability.
Book a discovery call
Tell us what you're trying to make deterministic — we'll walk your setup and where the platform fits.
- We walk your current agent setup together
- A concrete next step, not a sales call
- A reply within one business day