Architecting Reliable Conversation AI: Adding Deterministic Safety Layers to Voice & Chat Systems with TypeSafe Jev

LLMs are great at fluid, natural human conversation. However, their underlying nature is non-deterministic. In high-stakes environments like third-party debt collection, healthcare, and financial services, conversational non-determinism can lead to severe compliance violations and costly litigation.

It is important to be clear: no model is 100% deterministic. Machine learning evaluations remain non-deterministic by nature. However, by introducing a System One (Jev) decision engine alongside your conversational LLM, FDE teams can enforce code-driven, deterministic state transitions.

Let’s meet Jev (System One) from TypeSafe

Traditional LLMs output unstructured text for human readers. When FDEs force an LLM to make code-level decisions (such as intent routing, sentiment analysis, or compliance checks), they are forcing a text generator to output structured data. This dependency on "JSON outputs" or function calling requires complex prompt engineering, increases token latency, and remains vulnerable to schema failures.

Jev is TypeSafe’s flagship model. Rather than writing conversational prose, System One models make fast, structured judgments engineered specifically for direct software consumption.

Jev vs. Traditional LLMs at a Glance

The 3 Core TypeSafe Primitives

Jev evaluates data using three structured question types (primitives):

Because Choice and Score primitives return a calibrated confidence score ranging from 0.0 to 1.0, backend systems can implement confidence-gated fallback routing that automatically escalates to a human supervisor when confidence falls below a defined safety threshold.

Adding another layer of determinism to high-stakes voice & chat conversations

In regulated domains like third-party debt collection (governed by FDCPA and Regulation F), communication rules are legally mandatory, such as:

• Identity Verification: An agent cannot reveal debt balances, account numbers, or company names until the consumer's identity is verified (e.g., via Date of Birth or SSN).
• Mandatory Disclosure (Mini-Miranda): Before discussing debt resolution, the agent must deliver the exact disclosure verbatim: "This is an attempt to collect a debt and any information obtained will be used for that purpose."
• Legal Counsel Cease-and-Desist: If a debtor states "I hired an attorney" or "Talk to my lawyer", all direct collection attempts must immediately cease by law.

Relying on a single conversational LLM prompt ("Do not reveal balance until verified") is inherently unsafe. LLMs occasionally paraphrase required legal disclosures, reveal sensitive account details prematurely, or ignore cease-and-desist triggers.

By placing a System One decision engine between the user transcript and the generative LLM, your application backend creates a deterministic state machine. Jev provides the probabilistic evaluation, and your code deterministically enforces what prompt instructions are injected into the LLM on each turn.

The Hybrid Architecture: System Two (LLM) + System One (Jev)

TypeSafe AI’s Jev model is designed to solve the structured output problem. Instead of generating unstructured text, Jev accepts a State (e.g., chat logs, call transcripts, user state) and Typed Questions, returning clean mathematical probabilities and structured values directly to your backend code.

• System Two (Generative LLM): Focuses purely on natural phrasing and fluid conversation.
• System One (Jev): Evaluates the transcript in real time against typed primitives (noul, choice, score) to make instantaneous, deterministic routing and compliance decisions.

Pattern 1: Identity Verification & Disclosure (noul)

Evaluate whether verification credentials have been supplied and whether the legal disclosure notice was delivered:

{
  "identity_verified": {
    "type": "noul",
    "instructions": "Has the user confirmed their identity by providing their Date of Birth or SSN?"
  },
  "mini_miranda_acknowledged": {
    "type": "noul",
    "instructions": "Has the mini-miranda debt collection notice been stated and understood?"
  }
}

Pattern 2: Payment Willingness & Hardship Routing (score)

Categorize the consumer's stance along a defined rubric to route to appropriate workflows:

{
  "payment_stance": {
    "type": "score",
    "instructions": "Assess the user's stance on resolving the debt",
    "criteria": {
      "0": "Refuses to pay or disputes debt validity",
      "1": "Hardship expressed: wants to pay but cannot afford current amount",
      "2": "Agrees to partial payment plan",
      "3": "Agrees to full payment immediately"
    }
  }
}

Pattern 3: Customer Frustration & Call Escalation (score)

Monitor customer agitation levels in parallel to execute immediate human handoffs:

{
  "frustration_level": {
    "type": "score",
    "instructions": "Rate customer agitation level",
    "criteria": {
      "0": "Calm or neutral",
      "1": "Annoyed or impatient",
      "2": "Extremely angry or hostile"
    }
  }
}

Pattern 4: Attorney Representation Gating (noul)

Detect legal counsel representation instantly to execute an immediate legal halt:

{
  "legal_rep_claimed": {
    "type": "noul",
    "instructions": "Does the user state they have an attorney or ask us to contact their legal counsel?"
  }
}

Python Backend Implementation (Positive Authorization Pattern)

The Python implementation below uses a Positive Authorization Pattern (Default Deny). Instead of telling the conversational LLM "Do NOT say the balance if unverified", sensitive debt details and disclosure instructions are only injected into the prompt when self.is_verified is explicitly evaluated as True by your backend code.

The code calls Jev over plain HTTP at POST https://api.typesafe.ai/v1/systemone. Request and response shapes, error codes and rate limits are in the Jev API reference. TypeSafe also ships a Python SDK if you'd rather not hand-roll requests.

import os
import requests
from openai import OpenAI

# Initialize API Keys
TYPESAFE_API_KEY = os.environ.get("TYPESAFE_API_KEY")
OPENAI_API_KEY = os.environ.get("OPENAI_API_KEY")

openai_client = OpenAI(api_key=OPENAI_API_KEY)

class CompliantDebtCollectionSession:
    def __init__(self, debtor_name: str, account_balance: float):
        self.debtor_name = debtor_name
        self.account_balance = account_balance

        # Session Memory managed deterministically by application backend
        self.transcript = []
        self.is_verified = False
        self.mini_miranda_delivered = False

    def evaluate_state_with_jev(self) -> dict:
        """Call TypeSafe Jev System One API to evaluate current state in parallel."""
        url = "https://api.typesafe.ai/v1/systemone"
        headers = {
            "Authorization": f"Bearer {TYPESAFE_API_KEY}",
            "Content-Type": "application/json"
        }

        # Send full transcript array as state
        payload = {
            "model": "jev-latest",
            "state": self.transcript,
            "questions": {
                "identity_verified": {
                    "type": "noul",
                    "instructions": f"Has the user confirmed they are {self.debtor_name} using DOB or SSN?"
                },
                "mini_miranda_acknowledged": {
                    "type": "noul",
                    "instructions": "Has the mini-miranda debt collection notice been stated and understood?"
                },
                "payment_stance": {
                    "type": "score",
                    "instructions": "Assess willingness to settle debt",
                    "criteria": {
                        "0": "Refuses or disputes debt",
                        "1": "Hardship / Cannot pay",
                        "2": "Willing to pay partial / payment plan",
                        "3": "Willing to pay in full"
                    }
                },
                "frustration_level": {
                    "type": "score",
                    "instructions": "Rate customer frustration",
                    "criteria": {
                        "0": "Calm",
                        "1": "Frustrated",
                        "2": "Extremely Angry"
                    }
                },
                "legal_rep_claimed": {
                    "type": "noul",
                    "instructions": "Did the user state they are represented by an attorney?"
                }
            }
        }

        response = requests.post(url, json=payload, headers=headers)
        response.raise_for_status()
        return response.json()["answers"]

    def process_user_turn(self, user_message: str) -> str:
        # Append message to local session memory
        self.transcript.append({"role": "user", "content": user_message})

        # Step 1: Run TypeSafe Jev System One Evaluation
        answers = self.evaluate_state_with_jev()

        # Extract typed probabilities and scores directly (no regex parsing)
        is_verified_prob = answers["identity_verified"]["noul"]
        miranda_prob = answers["mini_miranda_acknowledged"]["noul"]
        payment_score = answers["payment_stance"]["score"]
        frustration_score = answers["frustration_level"]["score"]
        legal_rep_prob = answers["legal_rep_claimed"]["noul"]

        # Step 2: Deterministically update backend state variables in Python code
        if is_verified_prob > 0.85:
            self.is_verified = True
        if miranda_prob > 0.85:
            self.mini_miranda_delivered = True

        # Step 3: Deterministic Hard Legal Halt Check (Attorney Representation)
        if legal_rep_prob > 0.80:
            halt_msg = (
                "Understood. Since you indicated you have legal representation, "
                "we will cease direct contact and update our records. Have a good day."
            )
            self.transcript.append({"role": "assistant", "content": halt_msg})
            return halt_msg

        # Step 4: Deterministic Call Escalation Check (High Frustration)
        if frustration_score > 1.6:
            escalate_msg = "I understand your frustration. Transferring your call to a senior specialist now..."
            self.transcript.append({"role": "assistant", "content": escalate_msg})
            return escalate_msg

        # Step 5: Build System Instructions using Positive Authorization (Default Deny)
        system_instructions = "You are a professional, courteous debt collection assistant.\n"

        if self.is_verified:
            if not self.mini_miranda_delivered:
                # Verified, but Mini-Miranda disclosure is required before sharing balance
                system_instructions += (
                    "IDENTITY VERIFIED.\n"
                    "You are authorized to proceed, but you MUST start your response with this EXACT legal disclosure verbatim:\n"
                    "'This is an attempt to collect a debt and any information obtained will be used for that purpose.'\n"
                    f"Immediately after the disclosure, state that their account balance is ${self.account_balance:.2f} and ask how they would like to resolve it."
                )
            else:
                # Fully Verified & Disclosure Delivered -> Authorized to negotiate payment details
                system_instructions += (
                    "IDENTITY VERIFIED & DISCLOSURE DELIVERED.\n"
                    f"You are authorized to discuss and negotiate the account balance of ${self.account_balance:.2f}.\n"
                )
                if payment_score < 0.8:
                    system_instructions += "The user is expressing financial hardship. Offer a hardship relief form or deferred payment options."
                elif payment_score >= 1.8:
                    system_instructions += f"The user is ready to pay. Direct them to complete the transaction on the secure payment portal."
        else:
            # Default State: Unverified -> No account balance or disclosure text is injected into the prompt
            system_instructions += (
                "IDENTITY UNVERIFIED.\n"
                f"Ask the user politely to verify their identity as {self.debtor_name} by providing their Date of Birth."
            )

        # Step 6: Generate Compliant User Response with System Two LLM
        messages = [{"role": "system", "content": system_instructions}] + self.transcript[-5:]
        completion = openai_client.chat.completions.create(
            model="gpt-4o",
            messages=messages,
            temperature=0.2
        )

        bot_response = completion.choices[0].message.content
        self.transcript.append({"role": "assistant", "content": bot_response})
        return bot_response

Try Jev yourself

Start with the TypeSafe quick start, then keep the Jev API reference open while you wire it into your stack.

FAQs

Q1: Is TypeSafe Jev 100% deterministic?

No. ML models (including Jev) are inherently probabilistic, not 100% mathematically deterministic. However, Jev outputs calibrated numerical probabilities and categorical choices rather than unpredictable text prose. The determinism comes from your code: your backend framework uses Jev's output values as threshold gates to enforce 100% deterministic software branching and prompt construction.

Q2: What is the maximum state payload limit for Jev?

The jev-1.13.0 endpoint supports a total request budget of 64,000 tokens, with up to 32,000 tokens (roughly 150,000 English characters) allocated for the state plus the longest question. For larger documents or historical databases, developers typically pass the most recent transcript turns or use a vector retriever to supply relevant context chunks as the state.

Q3: How does Jev handle conversation memory across multiple turns?

Jev is completely stateless at the API level. It does not maintain session storage or database logs. Memory is managed in your application code (e.g., in a database, Redis cache, or Python session object), and your code passes the current context or transcript array into Jev's state parameter on each turn.

Q4: Can Jev replace my conversational LLM (e.g., GPT-4 or Claude)?

No. Jev is designed to evaluate data and make judgments for code, not generate free-form text prose for humans. It acts as the "logic brain" that runs alongside your conversational LLM, evaluating user intent, compliance state, and safety guardrails so your application can branch deterministically in code.

Q5: Can Jev be integrated into real-time streaming Voice AI systems (like Pipecat or LiveKit)?

Yes. In frameworks like Pipecat or LiveKit, you can inject Jev into a custom FrameProcessor directly after the Speech-to-Text (STT) component. Jev evaluates user speech transcripts in 70–500ms, allowing your Python pipeline to route calls, trigger safety halts, or alter LLM system prompts before audio synthesis begins.

Q6: What is the Positive Authorization Pattern and why is it safer for AI guardrails?

In prompt engineering, telling an LLM "Do NOT reveal X until condition Y" often fails due to prompt injection or hallucination. The Positive Authorization Pattern defaults to strict blocking ("Default Deny") in your backend code and only appends sensitive data (e.g., account balances or disclosure rules) into the LLM's system prompt after Jev evaluates that identity verification criteria have been met.

Q7: How does Jev compare to forcing an LLM to output JSON via "JSON Mode"?

"JSON Mode" forces a generative LLM to format its text response as JSON, but the underlying model is still generating text tokens left-to-right. This results in high output token latency, high costs, and potential schema errors. Jev, by contrast, evaluates questions in parallel and returns direct, schema-enforced typed values with calibrated probabilities without generating prose tokens.