What Makes an Architecture AI-Native?

Most teams that claim an "AI-native" product have shipped a deterministic application with a chat box on the side. The model answers questions. The system of record still runs the same way it did last year. That gap — between a feature and a control plane — is what this article tries to name.

Bolting a model onto a deterministic system#

Take a support platform. The retrofit version adds a classifier: ticket text in, category label out, then the existing routing rules fire. Useful. Still not AI-native. The model never owns the path; it annotates a path that was already hard-coded.

An AI-native version puts the model in the request path with real side effects: it decides which systems to query, which tools to call, what to write back, and when to stop — under budgets you define. Failure modes change. Latency becomes variable. Correctness is no longer a boolean unit test. If your architecture assumes none of that, you bolted a model on. You did not redesign the system.

The distinction matters because the operational work follows the architecture. Retrofits need prompt tweaks. AI-native systems need loop bounds, context budgets, tool contracts, and eval harnesses from day one.

Five properties that actually matter#

Skip the slogans. A system earns the label when these hold in production, not on a slide:

1. The model is a runtime dependency, not a plugin. If the model provider is down, a core workflow degrades or stops — not a "smart suggestions" panel. That sounds risky because it is. You design for it: timeouts, fallbacks, degraded modes.
2. Control flow is probabilistic, with deterministic bounds. Branches can vary by call. Max steps, max tokens, max tool invocations, and hard allowlists do not.
3. Context is engineered state. You assemble what enters the window on purpose — retrieved facts, tool results, policy snippets, user memory — under a budget. Dumping the ticket history into a prompt is not context engineering.
4. Tools are the real API surface. The model proposes; typed tools execute. Side effects go through contracts you own, not free-form "please update Salesforce" prose.
5. Evaluation sits in the loop. You score trajectories and outcomes on every meaningful change, not in a quarterly red-team exercise.

None of these require a multi-agent swarm. A single bounded loop with good tools and evals is more "AI-native" than five agents sharing a Slack channel.

A minimal shape#

The architecture is usually boring once you strip the hype: assemble context, call the model, optionally run a tool, append results, repeat until done or capped, then score.

type Step =
  | { type: "complete"; answer: string }
  | { type: "tool"; name: string; args: Record<string, unknown> };

async function handleRequest(input: string, ctx: AssembledContext) {
  const trail: string[] = [];
  for (let i = 0; i < 5; i++) {
    const step: Step = await plan(input, ctx, trail);
    if (step.type === "complete") {
      await scoreTrajectory(trail, step.answer); // eval hook, not a TODO
      return step.answer;
    }
    const result = await runTool(step.name, step.args); // allowlisted
    trail.push(`${step.name}: ${JSON.stringify(result)}`);
    ctx = await refreshContext(ctx, result);
  }
  throw new Error("loop budget exhausted");
}

What matters in that sketch is not the TypeScript. It is the invariants: a hard loop cap, tools behind a gate, context refreshed deliberately, and a scoring call that is part of the path — not a comment for later.

What you can drop#

You do not need a vector database on day one if your corpus fits in curated documents. You do not need five agents when one planner with three tools works. You do not need fine-tuning before you have evals that catch regressions.

What you should not drop: budgets, allowlists, and a way to replay a bad trajectory. Those are the difference between a demo and something you can sleep on.

Summary#

AI-native is not a marketing label for "we call an LLM." It is an architectural commitment: the model participates in control flow, context is treated as engineered state, tools mediate side effects, and evaluation is continuous. Bolting a model onto a deterministic system can still create value — just call it what it is, and do not expect retrofit ops to behave like native ones.