Skip to content

Labs

The permit desk: an AI platform you can watch

A fictional city’s permit reviews on durable workflows, an LLM gateway and retrieval. Run one live or watch a recorded run, break it on purpose, and read every step in the console.

trigger.dev · LiteLLM · Claude Haiku 5.5 · Workers AI · hybrid RAG · Langfuse · evals

The engine is open source, MIT: read the code on GitHub.

In 30 seconds

An AI platform that reviews permit applications for two fictional cities: it reads each application, checks it against the city’s code, and recommends a decision that a person signs off.

eval runs recommended what the city’s code says (on the set it was tuned on)
60 of 60
model cost per application
0.08¢–0.28¢
scenarios beyond the normal run: crashes, outages, loops
8
tests in the open-source engine
127

What happens to a permit application?

Port Alder and Kestrel Bay are cities that don’t exist, and so are their applications. Pick a scenario, play it, and click any box.

Pick a scenario

A normal run Recorded

A bakery’s application goes through all seven steps, waits for a person to sign off on the recommendation, and gets its report.

What it shows Long work runs off the request: the API answers 202, a worker does the steps, and each step is checkpointed.

  1. Intaketo do
  2. Extract fields (calls a model)to do
  3. Search the codeto do
  4. Check eligibility (calls a model)to do
  5. Registry lookupto do
  6. Recommend (calls a model)to do
  7. Person signs offto do
  8. Write the reportto do
Permit officeYour appbusyPlatform APICloudflare WorkersbusyTenant queuestrigger.dev queuesidleWorkerstrigger.dev runsidleRun statetrigger.devidleCode searchHybrid · bge-m3idleLLM gatewayLiteLLMidleModelsClaude Haiku 5.5idleState registryMock outside APIidleApprovaltrigger.devidleDead letterOur workflow SDKidleReportsRun outputidleAudit logAppend-only logidle1
Permit officeYour appbusyPlatform APICloudflare WorkersbusyTenant queuestrigger.dev queuesidleWorkerstrigger.dev runsidleRun statetrigger.devidleCode searchHybrid · bge-m3idleLLM gatewayLiteLLMidleModelsClaude Haiku 5.5idleState registryMock outside APIidleApprovaltrigger.devidleDead letterOur workflow SDKidleReportsRun outputidleAudit logAppend-only logidle1
  • Idle
  • Working
  • Retrying or waiting
  • Failed
  • Done
  • A request
  • A reply

Click any box for details. Space plays or pauses; the arrow keys step.

Port Alder sends application pa-bakery-0141; the API answers 202 Accepted.

City
TimeCityRunActorActionObject
+0.00 sPort Alderpa0141happysystemrun.acceptedpa-bakery-0141
Read “A normal run” as text (40 steps)
  1. +0.00 s Port Alder sends application pa-bakery-0141; the API answers 202 Accepted.
  2. +0.00 s The run is queued.
  3. +0.00 s The job joins Port Alder’s queue at position 1.
  4. +5.08 s Worker w2 takes the job.
  5. +5.08 s The run is running.
  6. +7.46 s Intake starts.
  7. +7.46 s Intake done in 0 ms. Application pa-bakery-0141 received; the form is complete.
  8. +7.46 s Intake is checkpointed.
  9. +7.47 s Extract fields starts.
  10. +7.47 s The worker asks Claude Haiku 5.5 through the LLM gateway, with Port Alder’s key (…7ASw).
  11. +12.74 s Claude Haiku 5.5 answers in 5.27 s: 351 tokens in, 300 out, $0.0002.
  12. +12.87 s Extract fields done in 5.41 s. 7 fields read from the letter.
  13. +12.88 s Extract fields is checkpointed.
  14. +12.88 s Search the code starts.
  15. +13.10 s Code search returns 5 sections.
  16. +13.10 s Search the code done in 229 ms. 5 code sections found.
  17. +13.10 s Search the code is checkpointed.
  18. +13.10 s Check eligibility starts.
  19. +13.11 s The worker asks Claude Haiku 5.5 through the LLM gateway, with Port Alder’s key (…7ASw).
  20. +15.87 s Claude Haiku 5.5 answers in 2.77 s: 1,199 tokens in, 506 out, $0.0004.
  21. +15.87 s Check eligibility done in 2.77 s. Meets 3 of 3 rules.
  22. +15.87 s Check eligibility is checkpointed.
  23. +15.87 s Registry lookup starts.
  24. +15.87 s The state registry answers 200 after 41 ms.
  25. +15.87 s Registry lookup done in 1 ms. Business registered and in good standing.
  26. +15.87 s Registry lookup is checkpointed.
  27. +15.87 s Recommend starts.
  28. +15.87 s The worker asks Claude Haiku 5.5 through the LLM gateway, with Port Alder’s key (…7ASw).
  29. +18.48 s Claude Haiku 5.5 answers in 2.60 s: 1,218 tokens in, 493 out, $0.0004.
  30. +18.48 s Recommend done in 2.60 s. Recommend approve, citing 4 sections.
  31. +18.48 s Recommend is checkpointed.
  32. +18.48 s The run parks at the approval and waits for a person.
  33. +18.48 s The run is waiting for a person.
  34. +30.27 s The reviewer approves.
  35. +30.27 s The run is running.
  36. +30.27 s Write the report starts.
  37. +30.27 s The report is written: approve, citing 4 sections.
  38. +30.27 s Write the report done in 1 ms. Decision report written: approve.
  39. +30.27 s Write the report is checkpointed.
  40. +30.27 s The run is completed.

How often does it recommend what the code says?

A golden set of applications whose right answer the city’s code decides, run through the real workflow several times each and scored by code.

20 fictional applications (12 from Port Alder, 8 from Kestrel Bay), each run 3 times through the real workflow on the production gateway, 2026-11-13.
ScorePasses when itNowFirst run
DecisionRecommended what the city’s code says60/60 · 100%25/60 · 42%
CitationsCited the sections the decision rests on, and never the planted note60/60 · 100%51/60 · 85%
RetrievalSearch returned those sections (deny and refer only)33/33 · 100%24/33 · 73%
ExtractionRead every field a rule turns on as the letter wrote it60/60 · 100%57/60 · 95%

Claude Haiku 5.5, engine ba677a9. The median attempt took 10.6 s from intake to report; the whole run cost $0.07. No case missed on any attempt. Every score is code checking the answer against the golden set: no model grades a model.

The fixes between the first run (6b1a238) and this one were made after reading this same set’s misses, in their traces. So the score says the desk now gets these 20 right, not that it would get new applications right. The honest next measure is a second set, written before anyone sees its results.

How are the agents orchestrated?

Seven steps and a person. Three of the steps call a language model; code decides everything around those calls.

The desk is a workflow with agents inside it, not one agent free to pick its own tools. Code owns the order of the steps, the retries, the budget and the rules a decision must follow. The model is called only where reading language is the job: reading the letter, judging each rule, drafting the recommendation. That keeps every run predictable, testable and cheap. Each recorded run made 2 to 5 model calls and spent $0.0008 to $0.0028.

  1. Intake no model
    What it does
    Checks the form is complete, records the run and writes the first audit entry.
    What checks it
    The API has already answered 202, so the permit office never waits on the work.
    What runs it
    A trigger.dev run, picked from its city’s queue.
  2. Extract fields Claude Haiku 5.5
    What it does
    Reads the applicant’s letter into typed fields: business, type, zone, staff, hours, seats, sign area, kitchen, certificates and licences.
    What checks it
    The answer must parse as JSON against a zod schema, with one more try if it doesn’t. Then a Python step checks the fields and flags any a person must look at.
    What runs it
    The worker calls the LLM gateway with the run’s own key; Python runs through trigger.dev’s Python extension.
  3. Search the code bge-m3 (embeddings)
    What it does
    Finds the sections of the city’s code that apply: keywords and meaning, fused into one ranking, top 5.
    What checks it
    Only the asking city’s sections can be found. A section that gives the model orders is quarantined: shown, but kept out of the prompt.
    What runs it
    An in-memory index in the worker; the query vector comes from Workers AI.
  4. Check eligibility Claude Haiku 5.5
    What it does
    Judges each rule as met or not met, from the fields, the letter and the clean sections, and may ask to search again.
    What checks it
    At most 3 turns. The letter sits in its own block marked as data, so a sentence in it can’t act as an instruction.
    What runs it
    One gateway call per turn, each its own generation in the trace.
  5. Registry lookup no model
    What it does
    Asks the state’s business registry, an outside API, whether the business is registered.
    What checks it
    Retries back off 1 s, 2 s, 4 s. After that the run goes to the dead-letter queue for a person.
    What runs it
    A step with the SDK’s retry policy for outside calls.
  6. Recommend Claude Haiku 5.5
    What it does
    Drafts approve, deny or refer, with a summary and the sections it rests on.
    What checks it
    Code turns an approval over a rule found unmet into a referral, and drops any citation search didn’t return clean.
    What runs it
    One gateway call, then plain code.
  7. Human approval no model
    What it does
    A person approves or rejects the recommendation.
    What checks it
    The run parks on a waitpoint and holds no worker. Nobody answering within 5 minutes ends it as expired.
    What runs it
    A trigger.dev waitpoint token, keyed by the run.
  8. Write the report no model
    What it does
    Writes the decision with the sections it cites.
    What checks it
    Written under a claim, so a second delivery of the same job never writes a second report.
    What runs it
    The last checkpointed step.

The guardrails every model call sits inside

  • Typed answersEvery model answer is parsed against a zod schema. A wrong shape gets one more try, then the step fails as a validation error instead of passing bad data on.
  • A call limit in the engineA run may make 12 model calls. The 13th is refused by the SDK and the run ends as budget exceeded.
  • A budget the gateway enforcesEach run gets its own LiteLLM key with $0.01 and a one-hour life, inside its city’s team budget of $2.50 every 30 days. A runaway loop is stopped by the gateway, not by hoping our own code is right.
  • Bounded loopsThe one loop, the eligibility check asking to read more, stops after 3 turns.
  • Retrieved text is dataSections and letters go into marked blocks the prompt calls data. Sections that address the model are quarantined when indexed and again when searched.
  • Only cite what was foundA citation that search didn’t return, or returned quarantined, is dropped and logged.
  • Code decides what the model mustn’tAn approval over an unmet rule becomes a referral that names the rule, so a person decides. The evals count these apart from the model’s own decisions.
  • A person signs offEvery permit recommendation waits for a human before its report is written.
  • Side effects happen onceIdempotency keys and claims make a second delivery harmless: the report is written once per run, whatever delivers the job.
  • Faults from an allowlistCrashes, outages and loops come only from a fixed list of scenarios in the engine, never from anything a visitor sends.

What platforms and tools is it built on?

Durable runs on trigger.dev, every model call through a LiteLLM gateway, search we wrote, traces in Langfuse, and evals that score every commit.

Orchestration

trigger.dev Cloud

Free plan

Durable runs: each application is one run that survives crashes, waits for people and queues per city.

What we configured
  • Task permit-run with 2 attempts; a retried attempt reads its checkpoints from the run’s metadata and skips finished steps.
  • Concurrency of 5 per key, triggered with the city as the concurrency key: one queue per tenant.
  • Approvals are waitpoint tokens with a 5-minute timeout and an idempotency key per run.
  • The Python build extension ships the field check with the task.
  • Deployed with CLI 4.8.2; production runs version 20261113.6.

Why: Durable execution, per-key queues and waitpoints without running a Temporal cluster. The Free plan’s $5 of monthly credits is a hard cap.

Our workflow SDK

Ours

The developer surface: a workflow is only its logic, and the SDK does the platform’s part.

What we configured
  • ctx.step() checkpoints, skips on resume and retries; ctx.llm() calls the gateway and parses the answer; ctx.search() searches one city; ctx.registry(), ctx.approval() and ctx.claim() handle the outside API, the person and side effects.
  • Every method emits the events this page plays and traces itself, so the workflow has no event or tracing code.
  • Two runtimes run the same workflow: trigger.dev, and an in-memory one with a virtual clock and a fake model, where the engine’s 127 tests run all nine scenarios without spending a cent.

Why: Teams building workflows shouldn’t each rebuild retries, budgets and tracing. Putting them in one SDK is what a platform team gives everyone else.

LLM gateway

LiteLLM proxy

Open source

The one door to every model: keys, budgets, fallbacks and the cost of each call.

What we configured
  • Image pinned at v1.106.6.
  • One team per city with $2.50 every 30 days; one key per run with $0.01 and a one-hour life, deleted when the run ends.
  • Claude Haiku 5.5 falls back to gpt-oss-120b; a fallback is reported in a response header, and so is each call’s cost.
  • Prices are set in the config from the providers’ price lists, so spend doesn’t depend on what this LiteLLM version knows. A test checks both configs against the engine’s table.
  • A provider-down route whose only model is a closed port, so the outage scenario really fails over.

Why: A gateway is a shared service every team calls, with per-tenant keys and budgets. Calling providers from each task would give fallbacks but no tenants and no budget anyone else can enforce.

Cloudflare Containers

Workers Paid

Hosts the LiteLLM container behind a small Worker.

What we configured
  • One Durable Object owns one container; it starts on the first request.
  • It sleeps after 2 minutes idle and wakes in about 60 s, which every run’s first call waits for and traces.
  • The Worker forwards only the chat, health, team and key routes; everything else, LiteLLM’s admin UI included, is a 404.

Why: Nothing is billed while it sleeps, and it runs inside a plan we already pay for.

Neon Postgres

Free plan

LiteLLM’s database: teams, keys and spend.

What we configured
  • A direct connection, because LiteLLM’s Prisma migrations can’t run through the pooler.
  • It scales to zero between runs.

Why: Serverless Postgres with a hard compute cap on the free plan.

Models

Claude Haiku 5.5

Anthropic

The three reading steps: extract, eligibility and recommend.

What we configured
  • $0.1 per million input tokens and $0.5 per million output.
  • Called only through the gateway, with the run’s key.

Why: Fast and cheap enough that a whole run costs a fraction of a cent, and good at structured answers.

gpt-oss-120b

Workers AI

The fallback when Claude fails.

What we configured
  • $0.35 per million input tokens and $0.75 per million output.

Why: A different provider on different infrastructure, so one outage doesn’t stop the desk.

bge-m3

Workers AI

Embeddings for the code’s sections and each search query.

What we configured
  • 1,024 dimensions. The index names the embedder that built it, and a query must use the same one.
  • The index is built once and shipped with the task.

Why: An open multilingual model, served on a Cloudflare account we already have, with no new vendor.

Retrieval and checks

Our hybrid index

Ours

Search over the two cities’ codes, with a citation for every section.

What we configured
  • One chunk per section, 20 in all, each tagged with its city. The city filter runs before ranking, so isolation is part of the query.
  • BM25 and vectors, fused by reciprocal rank (1 / (60 + rank) from each list).
  • Recall@5 on the golden queries: 0.898 hybrid, against 0.861 for keywords and 0.88 for vectors alone.
  • A screen flags text that addresses the model; a planted note in Kestrel Bay’s code proves it.

Why: Keywords win on section numbers and terms of art, vectors on paraphrases, and fusion wins when a planted document crowds the keywords.

Python field check

Ours

Checks the extracted fields: a business name, a zone code shaped like C-2, and staff, sign area, seats and event guests within range.

What we configured
  • Standard library only, run with trigger.dev’s Python extension.
  • A TypeScript copy runs where Python isn’t available, and a test keeps the two equal.

Why: Real platforms mix languages; this shows a polyglot step inside one durable run.

Observability

Langfuse Cloud

Free plan

One trace per run, sent by the engine over OpenTelemetry.

What we configured
  • Typed observations: the run as an agent, model calls as generations, the search as a retriever, the quarantine as a guardrail, the Python step and registry as tools.
  • The trace id comes from the trigger.dev run id, so a crashed run’s second attempt joins the first one’s trace.
  • Every input, output and metadata value is scrubbed before it leaves. Environments keep development, production and evals apart.
  • Eval scores are written onto each attempt’s trace. SDK 6.1.0.

Why: When a decision is wrong, the trace shows what the model saw and said at each step. That’s how the evals’ misses were found and fixed.

The console on this page

Ours

Audit log, logs, traces, spend and runs, filled from the same events as the diagram.

What we configured
  • Real durations and costs from the run beside the paced animation.
  • It’s also the text version of everything the diagram shows.

Why: An operator reads tables, not animations. The console is what you’d check at 3 a.m.

Evals

Our eval harness

Ours

Measures how often the desk recommends what the city’s code says.

What we configured
  • A golden set of fictional applications with the decision the code gives (9 approve, 6 refer, 5 deny), the sections it rests on and the ones it must never cite.
  • Each case runs several times through the real workflow, on the production gateway, with a run key per attempt.
  • Four scores, all code: decision, citations, retrieval and extraction. No model grades a model.
  • Each run writes a results file named by the engine commit, so a fix is measured against the run before it.

Why: A prompt change can fix one case and break three. Evals turn “seems better” into a number per commit.

This page

Next.js on Cloudflare Workers

OpenNext

Serves the page; the diagram and the run as text are rendered on the server.

What we configured
  • The page works before and without JavaScript; the player adds the motion.

Why: The site already runs here, so the lab adds no new hosting.

Our SVG diagram and Motion

Ours

The animated platform: boxes change state and packets travel the lines.

What we configured
  • Only opacity and transform move; reduced motion fades instead.
  • Pure functions turn events into each frame, so every animation is tested without a browser.

Why: Thirteen fixed boxes don’t need a graph library, and the page has to draw without JavaScript.

Live runs

Ours

Starts a scenario on trigger.dev production from this page and plays it as it happens.

What we configured
  • Five live runs a day per visitor, one at a time, and at most three at once in total; past three, a run waits and shows its place in line.
  • A visitor is a keyed hash of their IP address with a key for the day; the IP is never stored, and the rows go when the day ends.
  • trigger.dev’s REST API from the site’s Worker, with no SDK, and the runs’ events read every 2 seconds and scrubbed again.
  • Each run’s cost, as the gateway charged it, goes into a monthly meter that rests live runs before the hard caps.

Why: A replay proves a run happened once; a live run proves it happens now, with the visitor as the person who approves.

A typed event contract

zod

The boundary between the engine and this page.

What we configured
  • One versioned schema, copied into both repos and kept equal by a hash a test checks.

Why: The page and the engine were built and tested apart, against the contract.

trigger.dev, LiteLLM, Langfuse, Claude, Neon and Python and their logos are trademarks of their owners, used here only to name the tools the desk runs on; none of them sponsors or endorses Latitude 10. Cloudflare, the Cloudflare logo, and Cloudflare Workers are trademarks and/or registered trademarks of Cloudflare, Inc.

What happens when something fails?

Every failure has a place it’s caught. Most have a scenario above that shows it happen.

WhenWhat catches itWhereSee it
A worker dies mid-runtrigger.dev retries the run; the SDK finds each finished step’s checkpoint and skips it.trigger.dev and the SDKA worker crashes
An outside API answers 503Backoff of 1 s, 2 s, 4 s, then the dead-letter queue and a person.The SDK’s retry policyAn outside API fails
A job is delivered twiceIts idempotency key is already claimed, so the side effects don’t happen again.The SDK and run stateA job arrives twice
One city floods the deskIts own queue runs 5 at a time; the other city’s jobs don’t wait behind it.trigger.dev concurrency keysOne city sends 50 jobs
A model provider is downThe gateway falls back to gpt-oss-120b and reports the switch and its cost.LiteLLMA model provider is down
An agent loopsThe run’s key runs out and the gateway refuses the call; the engine’s 12-call limit is the second stop.LiteLLM and the SDKAn agent loops
A document gives the model ordersIt’s quarantined: shown in the results, kept out of the prompt and never cited.The index and the recommend stepA document gives orders
A person says no, or never answersThe waitpoint ends the run as rejected, or as expired after 5 minutes.A trigger.dev waitpointA person says no
The model answers in the wrong shapeOne more try; then the step fails as a validation error.The SDKUnit tests
The model approves over an unmet ruleCode refers it instead and names the rule.The workflowUnit tests
The gateway is asleepThe run’s first call waits up to about 60 s for the container, and the wait is traced.Cloudflare ContainersUnit tests

Where does the data on screen come from?

From the engine’s own events, scrubbed, recorded from production and replayed at a pace people can follow.

Every box that lights up and every packet that moves is one of 24 kinds of event from a real run. The diagram and the console read the same events, so the console is the text version of every animation.

  • The engine emits eventsThe SDK’s methods emit typed events as the run goes: steps, queue moves, model calls with tokens and cost, search results, outside calls, approvals and audit entries.
  • Scrubbed before they leaveEach event must match the strict schema, and every string is redacted (keys, bearer tokens, emails, query strings, IP addresses) and cut to its cap.
  • Kept with the runEvents are appended to the trigger.dev run’s metadata as they happen, beside the checkpoints.
  • Recorded into a replayThe recorder plays the platform API: it accepts and queues each run with its city as the concurrency key, completes approvals after the scenario’s wait, and merges every run’s events into one file named by the engine commit.
  • Reduced to a frameA pure function turns the events up to any moment into what the diagram and the console show then. Scrubbing the timeline is just asking for another moment.
  • Or played liveRun it live starts the same scenario on trigger.dev production. The site plays the platform API as the recorder does, reads the runs’ events every 2 seconds, scrubs them again and hands them to the same player. When the run asks for approval, you give it.
  • Paced for peopleThe screen’s clock follows the run’s, stretching so each step of a run stays at least 500 ms and cutting any wait to 2 s. Runs that overlapped overlap on screen. The engine runs at full speed; the console keeps the real times.

What did we choose not to use, and why?

Building a platform is mostly choosing what to leave out.

  • trigger.dev, not TemporalThe same durable-execution ideas (checkpoints, retries, waits for people) with nothing to operate, and a free plan with a hard cap. Cloudflare Workflows was the other option; trigger.dev’s per-key queues and waitpoint tokens fit the scenarios directly.
  • A gateway, not the LiteLLM SDK in each taskThe SDK gives fallbacks and cost, but not per-tenant keys, budgets or one service every team calls and an operator can watch.
  • One gateway, not twoLiteLLM replaces Cloudflare AI Gateway here; two gateways in a row would add latency and a second place to configure the same thing.
  • No vector database20 sections fit in one JSON file and a scan in memory takes well under a millisecond. You add a vector store when the corpus needs one, not because the product uses AI.
  • Traces from the engine, not LiteLLM’s callbackThe callback would log every call again as a trace of its own, unlinked from its run. The engine already records each call inside its run, with the cost the gateway charged.
  • Scores in code, not a model as judgeEach score can be checked against the golden set by anyone reading it. A model grading a model adds its own errors.
  • Our own harness, not Langfuse’s experiment runnerThe evals run the real workflow, traced the same way production is; the runner would wrap each case in a trace of its own.
  • Polling, not Realtimetrigger.dev’s Realtime needs a public token per run and a client SDK. Asking for the events every 2 seconds needs neither, and the pacing already holds the newest events back.
  • Our own SVG, not React FlowPan and zoom don’t help thirteen fixed boxes, and the diagram must render on the server without JavaScript.

What’s real and what’s fiction?

The platform is real; the cities are not.

Real

  • The durable runs on trigger.dev, their queues, retries, checkpoints, waits and crashes
  • Every model call, through the deployed gateway, with its tokens and the cost it was charged
  • The embeddings, the search and the quarantine
  • The budgets and the gateway’s refusal when one is spent
  • The audit log, the traces and the evals
  • Live runs: real runs on trigger.dev production, started from this page

Fiction

  • Port Alder and Kestrel Bay, their municipal codes and their permit offices
  • The businesses and their applications
  • The state business registry, which fails on purpose
  • The person approving, in a replay: the recorder answers after the scenario’s wait. In a live run, it’s you

Not yet

  • A live burst: 53 runs at once would take most of trigger.dev’s free plan for one visitor, so the burst plays its production recording only.
  • A held-out eval set: the score above was tuned on the same golden set it measures, so it shows the workflow learned those cases, not that it generalizes.

What does it cost to run?

Fractions of a cent per run, under hard caps that stop spending rather than bill more.

No new fixed monthly cost: every service is on a free plan or one we already pay for. What a run spends is what its model calls cost at the gateway, and the full eval run cost $0.07.

What each replay’s runs spent, counted from its events.
ScenarioRunsModel callsCostSource
A normal run13$0.0009Recorded on production, engine 88c4edb
A worker crashes13$0.0015Recorded on production, engine 88c4edb
An outside API fails26$0.0021Recorded on production, engine 88c4edb
A job arrives twice14$0.0014Recorded on production, engine 88c4edb
A person says no13$0.0009Recorded on production, engine 88c4edb
One city sends 50 jobs5353$0.0021Recorded on production, engine faabe50
A document gives orders15$0.0021Recorded on production, engine 88c4edb
An agent loops12$0.0008Recorded on production, engine 88c4edb
A model provider is down14$0.0028Recorded on production, engine 88c4edb

The hard caps

  • trigger.dev Free: $5 of credits a month, then runs stop.
  • LiteLLM: $2.50 per city every 30 days, and $0.01 per run.
  • Neon Free: 100 compute hours a month, then compute is suspended.
  • Anthropic: a spending limit on the workspace the labs share.