AALLM Docs

Route on constraints, then price

Build a deterministic routing decision that rejects incompatible deployments before optimizing cost.

What you will build

A router that separates hard constraints from preferences. Hard constraints decide eligibility; price and preferred providers only rank the eligible set.

1. Express the routing policy

TypeScript
type RoutingPolicy = {
  model: string;
  regions: string[];
  minimumContextTokens: number;
  requirePricing: boolean;
  capabilities: Record<string, "supported" | "conditional">;
  preferredProviders: string[];
};

const policy: RoutingPolicy = {
  model: "anthropic/claude-haiku-4.5",
  regions: ["eu", "global"],
  minimumContextTokens: 200_000,
  requirePricing: true,
  capabilities: {
    tool_calling: "supported",
    structured_output: "conditional",
  },
  preferredProviders: ["anthropic", "aws-bedrock"],
};

2. Filter hard constraints

TypeScript
const deployments = await allm.deployments.list({
  model: policy.model,
  lifecycle_status: "available",
  has_pricing: policy.requirePricing,
});

const eligible = deployments.data.filter((candidate) => {
  if (!policy.regions.includes(candidate.region)) return false;
  if (candidate.context_tokens === null) return false;
  if (candidate.context_tokens < policy.minimumContextTokens) return false;

  return Object.entries(policy.capabilities).every(([name, required]) => {
    const actual = candidate.capabilities[name]?.status;
    return required === "supported"
      ? actual === "supported"
      : actual === "supported" || actual === "conditional";
  });
});

3. Rank only eligible deployments

TypeScript
const ranked = await allm.deployments.compare({
  deploymentIds: eligible.map(({ id }) => id),
  inputTokens: 120_000,
  outputTokens: 12_000,
  cachedInputTokens: 80_000,
  requires: policy.capabilities,
});

const preferenceRank = new Map(
  policy.preferredProviders.map((provider, index) => [provider, index])
);

const selected = ranked.data.toSorted((left, right) => {
  const leftPreference = preferenceRank.get(left.deployment.provider_id) ?? 999;
  const rightPreference = preferenceRank.get(right.deployment.provider_id) ?? 999;
  return leftPreference - rightPreference ||
    Number(left.pricing.total_usd) - Number(right.pricing.total_usd);
})[0];

Preference ordering is a product choice

The API comparison is sorted by quote price. If provider preference, latency, data residency, or quality matters more, apply that ordering explicitly after compatibility filtering.

4. Persist an auditable decision

JSON
{
  "policy": "support-agent-eu-v3",
  "selected_deployment": "dep_anthropic_claude_haiku_4_5_messages_global",
  "eligible_count": 3,
  "representative_usage": {
    "input_tokens": 120000,
    "cached_input_tokens": 80000,
    "output_tokens": 12000
  },
  "quoted_total_usd": "0.112000",
  "decided_at": "2026-07-17T08:15:00Z"
}

No-match behavior

An empty set is a normal policy result, not an API outage. Choose an explicit product behavior: block the workflow, request human approval, relax one named constraint, or use a separately reviewed emergency policy. Never silently drop a capability requirement.