If you are building production AI systems, you have likely hit a frustrating wall. Your prompts are meticulously engineered, your retrieval-augmented generation (RAG) pipeline is fully operational, and yet your model still hallucinates, drifts off-topic, or gives wildly uncalibrated answers when faced with complex, multi-tenant payloads.
The problem isn't your prompt. The problem is your state architecture.
In early tutorials, passing a single customer message or a short transaction string into an AI model works seamlessly. But production systems don't handle single sentences. They handle massive JSON projections containing orders, users, historical messages, policies, feature flags, and latent workflow states.
If you treat your state as a passive "input payload" rather than a strict, traversable API contract, you are opening your application up to context rot, prompt injection, and statistical dilution.
Let's fix that.
To build reliable, sub-100ms decision loops with Jev, you need to understand the fundamental asymmetry of a System One architecture: The state is shared, but the questions are isolated.
When you submit a request to Jev, you pass a single state object alongside a collection of independent questions. Every question evaluates against that same state in parallel. No question sees another question's answer. The state is the only channel through which information flows.
Because of this, the state is not a neutral container. It is the terrain over which every judgment walks.
Think of your state object like the Document Object Model (DOM) in front-end development. You don't interact with a web page by dumping its raw text into a black box; you interact with it through a structured, addressable tree using CSS selectors.
Jev state works identically. When you write a question that targets ticket.messages[0].text, you are writing a selector. You are describing an absolute path through a structured object by walking named keys and numeric indices.
Similarly, think of a filesystem path like /var/log/nginx/access.log. The hierarchy encodes semantics and access models. A path like order.charges[0].status coerces the model's attention. It tells the reader—before a single byte of reasoning occurs—that this query is about a charge, it is the first charge in a list, and we are asking about its status, not its timestamp or amount.
Path specificity is inversely proportional to inference cost. The more completely a path specifies its target, the less the model must guess, and the more concentrated its probability distribution will be around the correct answer.
The concepts and code demonstrated here are drawn directly from my ebook Jev: The Definitive Guide to System One AI here. Check also the 9 volumes bundle: TypeScript AI & Agentic Engineer Masterclass
When designing your state schema, three competing priorities must be balanced: path clarity, update locality, and context isolation.
workflow.stages[2].steps[5].outputs.results[0].data.amount force the model to maintain too many cognitive frames of reference. This increases traversal cost, lowers confidence scores, and broadens probability distributions. Aim for a maximum of three to four levels of depth.
Let's look at a complete, end-to-end TypeScript program that puts these theoretical foundations into practice. This billing triage example handles a nested JSON state, uses backticked dot-and-index paths, evaluates three primitive types (noul, choice, and score) in a single parallel request, and composes the final business logic entirely in code.
// src/lib/triage.ts
import { TypeSafeClient, choice, noul, score } from "@typesafe-ai/sdk";
/**
* One per-process client. Reads `TYPESAFE_API_KEY` from the environment
* and defaults to `jev-latest`. Reuse this object across requests so
* the connection pool and retry policy stay warm.
*/
const client = new TypeSafeClient();
/**
* The `state` is the single blob of evidence the model reads to answer
* every question. Paths *inside* this object are the addressing surface
* that the questions point at, using backticked dot-and-index
* expressions such as `ticket.messages[0].text`.
*/
const state = {
ticket: {
id: "T-1042",
messages: [
{
from: "customer",
text: "I was charged twice for order A-104. Please refund the duplicate.",
},
{
from: "support",
text: "We are checking the charges.",
},
],
},
order: {
id: "A-104",
charges: [
{ amount_usd: 49, status: "captured" },
{ amount_usd: 49, status: "captured" },
],
},
refund_policy: "Duplicate charges are eligible for a refund.",
};
/**
* Every question is defined statically. The keys (`refund_requested`,
* `department`, etc.) are what the answers are keyed by in the response.
*/
const questions = {
refund_requested: noul(
"Does `ticket.messages[0].text` request a refund?",
),
duplicate_charge: noul(
"Do `order.charges[0].amount_usd` and `order.charges[1].amount_usd` match?",
),
policy_supports_refund: noul(
"Given `refund_policy`, does it support the request in `ticket.messages[0].text`?",
),
department: choice("Which team should handle `ticket.messages[0].text`?", {
billing: "Payment or subscription issues",
technical: "Bugs or integration problems",
sales: "Pricing or account questions",
}),
frustration: score(
"How frustrated is the customer in `ticket.messages[0].text`?",
[
"Calm and factual",
"Frustrated but civil",
"Very angry, strong language",
],
),
};
/**
* Orchestrates one triage pass in a single systemOne call.
*/
export async function triage(): Promise<void> {
const result = await client.systemOne({ state, questions });
const refund = result.answers.refund_requested.noul;
const duplicate = result.answers.duplicate_charge.noul;
const policy = result.answers.policy_supports_refund.noul;
const department = result.answers.department.choice;
const frustration = result.answers.frustration.score;
// Compose independent judgments into a deterministic business rule in code.
const shouldAutoRefund =
refund >= 0.8 && duplicate >= 0.8 && policy >= 0.8;
console.log({
department,
frustration,
shouldAutoRefund,
probabilities: result.answers.department.probabilities,
confidence: result.answers.department.confidence,
});
}
triage().catch(console.error);
Constructing new TypeSafeClient() once at the module level rather than inside your handler functions is critical. Reusing your client instance keeps your TLS setup, retry bookmarking, and keep-alive connection pools warm, preventing latency spikes in hot request paths.
Notice how the question instructions wrap paths in backticks: \ ticket.messages[0].text``. This is not mere formatting; it is a formal directive to the model. It instructs Jev to treat the token as a structural coordinate rather than generic text. Omitting backticks leads to inconsistent path resolution and brittle behavior when surrounding text happens to match keywords in your schema.
noul, choice, score)
Notice where the decision logic lives: entirely in TypeScript code (refund >= 0.8 && duplicate >= 0.8 && policy >= 0.8). The model’s job is strictly to evaluate normalized evidence against precise coordinates. Your code's job is to apply business thresholds to those calibrated outputs.
When scaling to multi-tenant architectures handling tens of thousands of requests, simple JSON payloads are no longer enough. You need physical retrieval isolation, path-rendering utilities, and request-scoped state management.
Below is an advanced architecture utilizing Node's AsyncLocalStorage to guarantee that concurrent tenant operations never cross contaminate, alongside a server action that integrates Pinecone vector search with Jev state projection.
lib/jev/state-shape.ts)
``typescript`
export type PathSeg = string | number;
export type StatePath = readonly PathSeg[];
export function renderPath(path: StatePath): string {
return path.reduce(
(acc, seg) => (typeof seg === "number" ? ```
acc[ {seg}]
: acc ? ```
acc.
{seg}
: seg),
"",
);
}
export const cite = (path: StatePath): string => \${renderPath(path)}``;
export function getAt(root: unknown, path: StatePath): unknown {
let node: unknown = root;
for (const seg of path) {
if (node === null || node === undefined) return undefined;
node = (node as Record)[seg];
}
return node;
}
export function setAt(root: T, path: StatePath, value: unknown): T {
if (path.length === 0) return value as T;
const [head, ...rest] = path;
if (Array.isArray(root)) {
const copy = root.slice();
copy[head as number] = setAt(copy[head as number], rest, value);
return copy as unknown as T;
}
const base = (root ?? {}) as Record;
return { ...base, [head]: setAt(base[head], rest, value) } as T;
}
export interface Candidate {
rank: number;
id: string;
similarity: number;
ageDays: number;
sourceType: "policy" | "contract" | "kb" | "forum";
title: string;
passage: string;
}
export interface ShapedState {
fastPath: {
entitlements: { plan: "free" | "pro" | "enterprise"; allowsAutoReply: boolean };
routing: { autoReplyFloor: number; escalateBelow: number; injectionCeiling: number };
};
task: { question: string; locale: string; channel: "email" | "chat" | "api" };
evidence: { index: string; namespace: string; topK: number; candidates: Candidate[] };
derived: { candidateCount: number; maxSimilarity: number; totalPassageChars: number; hasPolicySource: boolean };
}
export function project(state: ShapedState): Record {
return {
task: state.task,
evidence: state.evidence,
derived: state.derived,
};
}
`
lib/jev/scope.ts)
``typescript`
import { AsyncLocalStorage } from "node:async_hooks";
import { setAt, getAt, type ShapedState, type StatePath } from "./state-shape";
export const vectorNamespace = (tenantId: string): string => tenant:${tenantId};
export interface ScopeHandle {
readonly tenantId: string;
readonly requestId: string;
readonly state: ShapedState;
commit(path: StatePath, value: unknown): void;
at(path: StatePath): T;
}
const storage = new AsyncLocalStorage();
export function withScope(
init: { tenantId: string; requestId: string; fastPath: ShapedState["fastPath"] },
fn: (scope: ScopeHandle) => Promise,
): Promise {
let state: ShapedState = {
fastPath: init.fastPath,
task: { question: "", locale: "en", channel: "api" },
evidence: { index: "", namespace: vectorNamespace(init.tenantId), topK: 0, candidates: [] },
derived: { candidateCount: 0, maxSimilarity: 0, totalPassageChars: 0, hasPolicySource: false },
} as ShapedState;
const handle: ScopeHandle = {
tenantId: init.tenantId,
requestId: init.requestId,
get state() { return state; },
commit(path, value) { state = setAt(state, path, value); },
at(path: StatePath) { return getAt(state, path) as T; },
};
return storage.run(handle, () => fn(handle));
}
export function currentScope(): ScopeHandle {
const scope = storage.getStore();
if (!scope) throw new Error("No Jev scope open: call withScope() at the request boundary.");
return scope;
}
`
app/actions/answer-from-evidence.ts)
``typescript`
"use server";
import { Pinecone } from "@pinecone-database/pinecone";
import { choice, noul, score, RateLimitError, TypeSafeClient } from "@typesafe-ai/sdk";
import { passagePath, project, type Candidate } from "@/lib/jev/state-shape";
import { vectorNamespace, withScope } from "@/lib/jev/scope";
const JEV_MODEL = "jev-1.13.0";
const TOP_K = 12;
const INJECTION_SCAN_K = 6;
const jev = new TypeSafeClient({
apiKey: process.env.TYPESAFE_API_KEY!,
defaultModel: JEV_MODEL,
timeout: 4_000,
});
const pinecone = new Pinecone({ apiKey: process.env.PINECONE_API_KEY! });
const index = pinecone.index(process.env.PINECONE_INDEX!);
export async function answerFromEvidence(input: {
tenantId: string;
requestId: string;
question: string;
locale: string;
channel: "email" | "chat" | "api";
plan: "free" | "pro" | "enterprise";
}) {
return withScope(
{
tenantId: input.tenantId,
requestId: input.requestId,
fastPath: {
entitlements: { plan: input.plan, allowsAutoReply: input.plan !== "free" },
routing: { autoReplyFloor: 0.85, escalateBelow: 0.55, injectionCeiling: 0.7 },
},
},
async (scope) => {
// 1. Retrieve inside the tenant's physical namespace
const vector = [0.1]; // Mock embedding vector
const { matches } = await index.namespace(vectorNamespace(scope.tenantId)).query({
vector,
topK: TOP_K,
includeMetadata: true,
});
// 2. Shape and precompute scalars so Jev never does arithmetic
const now = Date.now();
const candidates: Candidate[] = matches.map((m, i) => ({
rank: i + 1,
id: String(m.id),
similarity: Number((m.score ?? 0).toFixed(4)),
ageDays: 2,
sourceType: "kb",
title: "Sample Doc",
passage: String(m.metadata?.text ?? "").slice(0, 1_200),
}));
scope.commit(["task"], { question: input.question, locale: input.locale, channel: input.channel });
scope.commit(["evidence"], { index: "idx", namespace: vectorNamespace(scope.tenantId), topK: TOP_K, candidates });
// 3. Build questions targeting precise paths
const core = {
best_passage: choice(
`Which passage in \` evidence.candidates\` states the answer to \`task.question\`?`,
{ ...Object.fromEntries(candidates.map((c) => [c.id, null])), none: "No matching passage." }
),
evidence_sufficient: noul(
`Do the passages in \` evidence.candidates\` contain everything needed to answer \`task.question\`?`
),
};
const questions = { ...core };
// 4. Execute single parallel call
const result = await jev.systemOne({ state: project(scope.state), questions, model: JEV_MODEL });
return {
success: true,
answers: result.answers,
};
}
);
}
`
ticket.messages[0].text without backticks forces the model to guess whether you are writing code or natural language prose, causing massive confidence drops. Always wrap paths in backticks.systemOne inside a loop for individual questions or separate tickets. Batch your questions into a single state payload and fan out ticket requests using Promise.all().{ tenantId: currentTenant }) leaves your database exposed to human error. Use physical storage namespaces (like Pinecone namespaces) and AsyncLocalStorage to enforce isolation at the infrastructure level.
State shaping is ultimately API design. When you treat your Jev state object as a structured, addressable contract rather than a messy string dump, everything changes.
By keeping paths shallow, precomputing scalars in code, enforcing request-scoped isolation, and pointing questions at exact coordinate paths, you transform LLM output from a probabilistic gamble into a reliable, high-performance engineering primitive. Structure your terrain properly, and your model will deliver crisp, calibrated answers every single time.