Decision Router API (System One) Technical Guide
Overview & Concept
The Decision Router API provides a unified FastAPI interface for high-volume policy checks, low-latency scoring, long-context log evaluations, and generative reasoning. These models allow applications to quickly execute structured decisions where input is minimal and typed data is required. They serve as a high-speed replacement for traditional Large Language Models (LLMs) in scenarios where execution speed and strict response schema are prioritized over narrative text generation.
Drawing from psychologist Daniel Kahneman’s concept of fast, automatic "System 1" thinking versus slow, deliberate "System 2" thinking, System One models execute fast forward-pass predictions that output typed data or probabilities directly. Unlike traditional chat interfaces that generate text token-by-token, these specialized models are built for fast, programmatic judgments that software can consume immediately without parsing errors.
Advantages & Limitations
| Advantages |
Limitations |
| Ultra-High Speed: Processes inputs in a single forward pass and skips token-by-token generation, running 100x to 200x faster than traditional LLMs. |
No Creative Output: Cannot generate prose, write essays, summarize articles in text, or compose emails. |
| Calibrated Probabilities: Outputs highly reliable percentages and confidence scores (e.g., precise toxicity or relevance metrics). |
Fixed Output Formats: Completely restricted to strict typed questions, pre-defined categories, or numerical scores. |
| Extremely Cost-Effective: Drastically lowers compute resource consumption by eliminating heavy generative token overhead. |
No Chain-of-Thought (CoT): Cannot break down complex, multi-step math or logic problems before outputting a result. |
| Deterministic Parsing: Eliminates LLM output variance, enabling downstream applications to reliably process output JSON without schema errors. |
Task-Specific: Built purely for evaluation, classification, routing, and guardrails, making it unsuitable for general-purpose conversation. |
Quick Start
| Configuration Parameter |
Value / Endpoint |
| Authorization Header |
X-API-Key |
| Base URL |
https://system-one.ai.hpc.fau.edu |
| List Models Endpoint |
GET /v1/models |
| Decision Endpoint |
POST /v1/decide |
| Rotate Key Endpoint |
POST /v1/auth/rotate-key |
| Swagger Documentation |
https://system-one.ai.hpc.fau.edu/docs |
Choosing the Right Engine Target (Model)
The /v1/decide endpoint accepts a model query parameter to route your request to the appropriate underlying CPU or GPU inference engine:
| Engine Target |
Architecture |
Target Latency |
Max Context |
Best Used For |
open-jev-deberta-v3-large |
CPU (ONNX) |
~15 ms |
512 tokens |
High-volume binary policy checks, guardrails, short log evaluations. |
laya |
CPU (ONNX) |
~20 ms |
512 tokens |
Confidence scoring, risk classification, escalation triggers. |
semif |
GPU (Gemma 4) |
~80–150 ms |
16,384 tokens |
Long-context documents, multi-option scoring, token-free decisions. |
simple-jev |
GPU (Gemma 4) |
~300 ms–1.5 s |
16,384 tokens |
Scenarios requiring free-form text explanations or detailed reasoning. |
Usage Examples
1. Self-Service API Key Rotation
If your key has been exposed or needs routine rotation according to compliance schedules, generate a new key using the rotation endpoint.
Important: Rotating your key immediately revokes and invalidates your previous key.
import requests
API_URL = "https://system-one.ai.hpc.fau.edu"
current_key = "YOUR_CURRENT_KEY"
response = requests.post(
f"{API_URL}/v1/auth/rotate-key",
headers={"X-API-Key": current_key},
)
if response.status_code == 200:
new_key = response.json()["new_api_key"]
print(f"Key rotated successfully. Your new key is: {new_key}")
else:
print(f"Rotation failed: {response.json()}")
2. List Available Models
Fetch active model metadata directly from the models endpoint.
import requests
headers = {"X-API-Key": "YOUR_KEY"}
response = requests.get(
"https://system-one.ai.hpc.fau.edu/v1/models",
headers=headers,
)
print(response.json())
3. open-jev-deberta-v3-large (Real-Time Policy Verification)
- Best for: Real-time access control checks, fast policy verification, and low-latency microservice guardrails.
- Limitations: Truncates inputs longer than 512 tokens. No narrative text generation.
import requests
headers = {"X-API-Key": "YOUR_KEY"}
payload = {
"state": "User accounts-service attempted 15 invalid login requests from IP 192.168.1.50 in 10 seconds.",
"questions": [
{
"instructions": "Should this IP address be rate-limited immediately?",
"type": "noul", # Yes/No evaluation
}
],
}
response = requests.post(
"https://system-one.ai.hpc.fau.edu/v1/decide?model=open-jev-deberta-v3-large",
headers=headers,
json=payload,
)
print(response.json())
# Output: {"model_used": "open-jev-deberta-v3-large", "results": [{"p_yes": 0.9851, "p_no": 0.0149}]}
4. laya (Risk Triage & Confidence Scoring)
- Best for: Secondary validation and evaluating whether human analyst escalation is required.
- Limitations: Optimized for binary and triage logic; not intended for unstructured prompts.
import requests
headers = {"X-API-Key": "YOUR_KEY"}
payload = {
"state": "High-value wire transfer requested for $45,000 from an unrecognized device in Paris.",
"questions": [
{
"instructions": "Does this transaction require manual Tier-2 fraud team escalation?",
"type": "noul",
}
],
}
response = requests.post(
"https://system-one.ai.hpc.fau.edu/v1/decide?model=laya",
headers=headers,
json=payload,
)
print(response.json())
5. semif (Long-Context Log Evaluation & Multi-Choice Scoring)
- Best for: Analyzing long incident logs, compliance documents, or selecting choices without generative LLM latency.
- Limitations: Returns option probabilities directly; does not generate explanatory text paragraphs.
import requests
headers = {"X-API-Key": "YOUR_KEY"}
payload = {
"state": """
[SYSTEM INCIDENT LOG]
08:12:01 - DB-01 CPU utilization exceeded 95%.
08:12:15 - Connection pool exhausted on auth-service-v2.
08:12:30 - Cache miss rate spikes on Redis node 3 following deployment commit #a8f3d1.
... [Multi-page log payload supported up to 16k tokens] ...
""",
"questions": [
{
"instructions": "Which subsystem is the primary root cause of this outage?",
"type": "choice",
"options": [
"Database CPU",
"Auth Service Memory",
"Redis Deployment",
"Network Partition",
],
}
],
}
response = requests.post(
"https://system-one.ai.hpc.fau.edu/v1/decide?model=semif",
headers=headers,
json=payload,
)
print(response.json())
# Output: {"model_used": "semif", "results": [{"top_option": "Redis Deployment", "probabilities": {"Redis Deployment": 0.912, ...}}]}
6. simple-jev (Generative Reasoning & Audit Explanations)
- Best for: Audit trails, natural-language explanations for decisions, and complex reasoning tasks.
- Limitations: Higher latency due to token-by-token generation.
import requests
headers = {"X-API-Key": "YOUR_KEY"}
payload = {
"state": "Customer requested a refund 35 days after purchase. Standard policy is 30 days, but the customer's product arrived damaged.",
"questions": [
{
"instructions": "Provide a policy exception decision and explain the rationale.",
"type": "choice",
"options": ["Approve Refund Exception", "Deny Refund"],
}
],
}
response = requests.post(
"https://system-one.ai.hpc.fau.edu/v1/decide?model=simple-jev",
headers=headers,
json=payload,
)
print(response.json())
API Error Handling Reference
| Status Code |
Description |
Resolution |
| 401 Unauthorized |
Missing or revoked X-API-Key. |
Verify the key header string or rotate credentials via POST /v1/auth/rotate-key. |
| 400 Bad Request |
Missing required parameters, such as options for type: "choice". |
Check payload formatting against the API schemas at https://system-one.ai.hpc.fau.edu/docs. |
| 500 Server Error |
Model engine inference timeout or backend failure. |
Check API health status at https://system-one.ai.hpc.fau.edu/health or contact hpc@fau.edu if service remains unreachable. |
Need Further Help?
For API key provisioning, high-volume endpoint quota adjustments, or HPC technical support, contact the OIT Help Desk: