LLMs are probabilistic.
Your production logic can't be.
Deterministic AI Reasoning.
An open specification and reference runtime for deterministic AI reasoning. Move from fragile prompts to enforceable Infrastructure-as-Code. Insert hard guardrails and guarantee auditability before your models output a single word.
Unstructured reasoning is an enterprise risk.
Prompt engineering is not systems engineering. Relying on an LLM to follow implicit system instructions exposes your application to catastrophic unpredictability.
Hallucination Liability
You can't catch every edge case with a system prompt. When your AI invents facts or product names, your business pays the price. Implicit routing fails silently.
Non-Reproducibility
Two identical prompts can yield entirely different reasoning structures. You cannot build reliable enterprise pipelines on shifting, unpredictable foundations.
Zero Auditability
When an agent makes a critical mistake, debugging a black-box conversation log is impossible. Compliance and security teams require formal trace logs, not chat histories.
The Manifesto
1. AI systems don't need to be caged.
AI can explore, reason, and act.
From the routine to the complex, at a scale no human can sustain.
The capability is real and it is expanding.
The right response to that power is not to clip its wings.
Blanket restriction doesn't make a system safer. It makes it smaller.
2. AI systems must be intentional.
You decide what the system should be before it starts acting.
Strict or loose, verified or trusted, autonomous or human-gated — all valid.
What is not valid is undeclared.
3. The topology is the contract.
A topology is a formal declaration of what the reasoning pipeline is — what executes, how it connects, what gets verified, who must approve.
Not a prompt.
Not a system instruction that might be followed.
A contract.
4. The runtime keeps the promise.
It does not decide.
It does not improvise.
It executes the topology faithfully, produces a trace of everything that happened, and refuses to proceed when obligations are unmet.
It keeps the promise.
Parley is the runtime.
The DRTL is the language.
The idea belongs to everyone.
How It Works
Enforceable reasoning topologies.
Structure governs reasoning — not prompts.
The Declarative Reasoning Topology Language (DRTL) defines an AI pipeline as a directed graph of typed epistemic operations.
If a model asserts a verifiable claim, the pipeline explicitly checks it against external reality. If the obligation is unmet, execution halts or routes deterministically to a fallback or human reviewer.
The Specification
Contracts enforced at runtime.
Declarative Reasoning Topology Language (DRTL) transforms reasoning from an implicit prompt into an explicit, version-controlled contract.
Define nodes, enforcement modes, and routing logic in declarative YAML. Every execution generates a canonical, tamper-evident trace log.
nodes:
- id: generate_summary
type: generate
prompt: Summarize Aurora Serverless v3 features
- id: verify_claims
type: verify
rules:
- id: std.check_existence
target: product_names
mode: block
- id: safety_gate
type: gate
condition: input.blocking_failures == 0
on_success: publish
on_fail: rejection
- id: rejection
type: review
actor: human
actions: [retry_with_search, reject, override]Reasoning Runtime
A deterministic execution engine for AI reasoning.
The runtime does not reason. It enforces reasoning.
It is responsible for:
- Compiling DRTL into a directed execution graph
- Executing typed nodes deterministically
- Enforcing verification modes (observe, warn, block)
- Halting execution when obligations are unmet
- Producing a canonical execution trace
- Pausing for human or policy review when required
Vendor-Agnostic Routing
Fallback from one model to another without rewriting prompts.
Topology remains stable.
Standard Verification Library
Deterministic rule validation:
- existence checks
- compute validation
- web search
- schema enforcement
Native Human-in-the-Loop
Review nodes pause execution deterministically. External approval resumes execution safely.
Auditable by Design
Every execution produces a canonical trace mapping extracted claims to routing decisions.
The topology defines intent. The runtime enforces it.
Vendor-neutral.
Model-agnostic.
Infrastructure-first.
Vendor-Agnostic Routing
Fallback from one model to another without rewriting prompts.
Topology remains stable.
Standard Verification Library
Deterministic rule validation:
- existence checks
- compute validation
- web search
- schema enforcement
Native Human-in-the-Loop
Review nodes pause execution deterministically. External approval resumes execution safely.
Auditable by Design
Every execution produces a canonical trace mapping extracted claims to routing decisions.