L2 · platform · multi-agent orchestration status: active

Agentic Runtime Platform¶

Declarative YAML workflows compile to executable DAGs — tiered routing across eight LLM providers, rubric-scored evaluation, and OpenTelemetry on every stage. Deterministic core; the LLM sits at the boundary. Built solo to production discipline: every consequential decision has an ADR, every quality gate is enforced in CI.

Get started Read the architecture View source

$ AGENTIC_NO_LLM=1 agentic run test_deterministic --input /tmp/test-input.json # zero-credential dev mode

Python 3.11+ FastAPI Pydantic v2 LangGraph React 19 OpenTelemetry mypy --strict

get running

Quick start in 60 seconds¶

No API keys required. The runtime ships with a deterministic placeholder backend that exercises every code path the real models do.

# 1. Clone and install
git clone https://github.com/tafreeman/agentic-runtime-platform.git
cd agentic-runtime-platform/agentic-workflows-v2
pip install -e ".[dev,server]"

# 2. Enable zero-credential mode
export AGENTIC_NO_LLM=1   # Windows: $env:AGENTIC_NO_LLM=1

# 3. Create an input file (--input accepts a file path, not inline JSON)
echo '{"task":"hello"}' > /tmp/test-input.json

# 4. Run a workflow
agentic run test_deterministic --input /tmp/test-input.json

In under a minute the DAG executor emits a structured run record — step timings, tool calls, and a final scored artifact.

Full walkthrough

pipeline

How it works¶

A workflow definition flows through a deterministic pipeline — YAML loader, graph compiler, DAG executor, model router — before reaching an LLM provider. Every stage emits OpenTelemetry traces and Pydantic-validated artifacts.

flowchart LR
    A[YAML Workflow] --> B[Loader
Pydantic v2 validate]
    B --> C[Graph Compiler
Kahn topo sort]
    C --> D[DAG Executor
asyncio fan-out / fan-in]
    D --> E[Model Router
tier · health · circuit breaker]
    E --> F[(Provider)]
    F -.observation.-> D
    D --> G[Artifacts
Pydantic contracts]
    style A fill:#262626,color:#f4f4f4,stroke:#33b1ff
    style F fill:#262626,color:#f4f4f4,stroke:#4589ff
    style G fill:#262626,color:#f4f4f4,stroke:#42be65

capabilities

Capabilities¶

Dual execution engines¶

Run any workflow through the native DAG executor or the LangGraph-backed engine. Both produce structurally equivalent output; agentic compare diffs them side by side.

Architecture overview

Tiered model routing¶

Steps declare a capability tier, not a model name. The SmartRouter resolves the best available provider at runtime — circuit breakers, adaptive cooldowns, automatic fallback chains.

Runtime engine

Eight LLM providers¶

OpenAI, Anthropic, Gemini, Azure OpenAI, Azure AI Foundry, GitHub Models, Ollama, and local ONNX / Windows AI — one client, per-provider bulkhead concurrency limits.

Tools & providers

Full RAG pipeline¶

Document loading, recursive chunking, deduplicated embedding, hybrid retrieval with Reciprocal Rank Fusion, cross-encoder and LLM reranking, token-budget context assembly.

RAG pipeline

Rubric-based evaluation¶

YAML-defined rubrics with weighted criteria and LLM-as-judge integration — each criterion scored on a normalized 0–1 scale, then weighted into a composite. Production gating is coverage_score >= 0.80 — not string matches.

Evaluation framework

Live dashboard¶

A React 19 SPA streams execution events over WebSocket. DAG nodes move through queued → running → complete in real time, with per-step drill-down into inputs, outputs, and timing.

UI dashboard

Zero-credential dev mode¶

AGENTIC_NO_LLM=1 installs deterministic placeholder providers at both engine chokepoints. The full test suite passes with zero provider credentials.

No-LLM dev mode

Windows-first support¶

Runtime and tooling validated on Windows in CI. scripts/setup-dev.ps1 is a one-command bring-up; the Windows AI Bridge (Phi Silica) is first-class.

Development guide

metrics

By the numbers¶

187K

Lines of Python

3,957

Backend tests

80%

Coverage gate, CI-enforced

50

ADRs

8

LLM providers

6

Production workflows

engineering practice

Engineering practice¶

Everything below is committed, versioned, and CI-enforced.

A written decision record¶

50 architecture decision records capture context, alternatives, and consequences for every consequential choice — engine adapters, wire-format contracts, storage backends, security boundaries. The reasoning is reviewable, not reconstructed.

ADR index

Correctness gated in CI¶

An 80% coverage gate (79.93% fails — no rounding up), ruff and strict mypy on the engine and contracts, and a wire-format drift job that regenerates JSON schemas and TypeScript types and fails on any mismatch.

Contributing & gates

Proven under load¶

The Redis-CAS circuit breaker and horizontal scale-out are load-tested with k6 against a multi-replica stack, and the report is generated from committed results — numbers, not adjectives.

Load proof

Governance, honestly scoped¶

A living NIST AI RMF alignment document, an OWASP-informed threat model, security hardening notes, and a maintained known-limitations page that says plainly what this platform does not do.

AI risk management

workflows

Production workflow definitions¶

The engine ships with six production workflow definitions:

Workflow	Pattern	Description
`code_review`	Fan-out / fan-in	Parse code → parallel architecture + quality reviews → synthesis
`bug_resolution`	Sequential with verification	Reproduce → root cause → fix → test → verify
`fullstack_generation`	Parallel sub-steps	API design → frontend + backend in parallel → integration
`iterative_review`	Multi-loop with bounded iteration	Review → feedback → revise until quality gates pass
`conditional_branching`	Conditional DAG	Steps execute or skip based on runtime conditions
`consensus_review`	Ensemble with majority vote	Three independent reviewers vote; summarize only on agreement

Workflow reference

documentation