# What Cromus Is — The Pre-Execution Layer for AI Workflows > Every other AI tool tells you what happened. Cromus tells you what will. Observability platforms trace your AI after it runs. Cost monitors total the bill after you've paid it. Eval tools score outputs after the tokens are spent. They are all, by design, past tense. Cromus is the layer before. It compiles your AI workflows into portable specs, then scores cost, risk, and governance **before a single token is spent** — deterministically, with no LLM calls in the analysis. You decide what's worth running before you run it. --- ## The one distinction that explains everything There is a line running through every AI tool, and which side of it you're on changes what you can possibly do. - **After execution** — you run the workflow, then a platform shows you what it cost, where it slowed down, and whether quality regressed. Useful. Necessary. But the money is already spent and the run already happened. You're reading the receipt. - **Before execution** — you see what a workflow will cost, where it's over-provisioned, and whether it violates your governance rules, *while you can still change it for free.* Editing a spec costs nothing. Re-running production does not. Cromus lives entirely on the "before" side. That's not a feature difference. It's a different job. > Observability answers *"what did my AI do?"* > Cromus answers *"what should my AI do — and what will it cost me?"* --- ## Why this isn't cost monitoring Cost-monitoring tools price the tokens you already burned. They read your traces, sum the spend, and group it by model or feature. Real value — but every number describes a call that already executed. Cromus estimates cost from the **workflow spec, before it runs at all.** No trace required, because there's nothing to trace yet. That means Cromus can tell you what a workflow will cost before you've built it, before you've shipped it, and before the bill exists — and show you which steps to change while changing them is still free. A monitor recomputes your past spend. Cromus simulates your future spend. Both recompute from verified model prices rather than trusting a vendor's number — but one is a rear-view mirror and the other is a forecast. --- ## Why this isn't observability or evals Observability and eval platforms answer a quality question: *did my AI produce good output, and did the last release make it worse?* To answer it, they have to run the AI and grade what comes out — usually with more LLM calls. Cromus answers a different question entirely — *is this workflow economical, governed, and portable?* — and answers it without running anything. The diagnostic path makes **zero LLM calls.** It reads structure, not output. That's why it's deterministic, repeatable, free to run, and auditable: the same workflow scores the same way every time, because no model is in the loop guessing. You'd use an eval platform to check if your agent is *correct*. You'd use Cromus to check if it's *worth running* — before you find out the expensive way. --- ## What Cromus actually does Three things, all upstream of the run: - **Compiles** your SOPs and workflows into portable, governed specs (SKILL.md, with ETHOS.md for behavioral rules and MEMORY.md for portable context). The governance lives *inside* the artifact, so your workflow carries its own rules into any runtime. - **Scores** cost, latency risk, failure risk, and structural gaps before execution — quantifying preventable waste deterministically, against a verified registry of real model prices. - **Governs** what's allowed to run: budget ceilings, model-downgrade rules, policy checks that pass or fail *before* deployment, not alerts that fire after something already went wrong. And because it never sits between your agent and the model, Cromus adds no latency and creates no runtime dependency. It hands a validated, portable artifact to whatever you run — and gets out of the way. --- ## Where it fits with the tools you already use Cromus doesn't replace your observability or eval stack. It sits in front of it. | | Cromus | Observability / Cost monitors | Eval platforms | |---|---|---|---| | **When** | Before execution | After execution | After execution | | **Question** | What should run, at what cost? | What did it cost / do? | Was the output good? | | **Method** | Deterministic, zero LLM calls | Trace-based | LLM/code/human scoring | | **You can still change it for free** | Yes | No — already ran | No — already ran | A complete AI stack has a "before" layer and an "after" layer. Most teams have only the after. Cromus is the before. --- ## Who it's for Anyone spending real money running AI workflows, who'd rather decide what's worth running than audit what already ran: - **Founders** protecting runway against invisible AI spend. - **Engineering & platform teams** putting a cost-and-governance gate in front of deployment. - **Agencies** protecting margin on AI-built client work — and reselling optimization to clients under their own brand. - **Regulated teams** that need governance enforced *before* an agent acts, not flagged after. --- ## The bottom line The market is full of tools that tell you what your AI did. That's the easy half — the run already happened, the data's just sitting there. The hard half, the one that actually saves money and prevents the incident, is knowing *before* you commit the compute. That's the half Cromus owns. **See what your workflow will cost before you run it.** - [Score a workflow free](https://cromus.ai/demo) - [Read the thesis: Why Cromus](https://cromus.ai/why-cromus) --- *Cromus is Workflow Intelligence as a Service — the deterministic, pre-execution layer that scores, governs, and makes AI workflows portable before tokens are spent.*