Most AI is one giant model in someone else’s data center. werbos is the opposite bet: a small model you own, pointed at a library you curate, with a verifier that refuses to guess. The clever part isn’t the weights — it’s the engine around them.

One line carries the whole design:

capability = model × library

The model is the cursor — the thing that reads, picks, and phrases. The library is the knowledge — everything the model is allowed to know. You grow capability by growing the library, not by renting a bigger model. That’s why it stays cheap, stays local, and stays yours.

The whole engine in one diagram

flowchart TD Q[/"You ask werbos something"/] --> ENG subgraph ENG["The werbos engine — runs on your box"] direction TB C["The cursor
a small model you own
reads · picks · phrases"]:::cursor L["Your library
curated knowledge packs
the model is allowed to know"]:::lib V["The verifier
grades every answer
before it reaches you"]:::ver C <--> L C --> V end V --> G{Passed the grade?} G -- "yes" --> A["Grounded answer
+ where it came from"]:::ok G -- "no" --> H["Honest abstain
“I don't know”"]:::abstain A --> LEARN["Verified answers get
written back to the library"]:::learn LEARN -.->|"next time it's instant"| L classDef cursor fill:#f0d4c5,stroke:#a04d2f,color:#1a1916; classDef lib fill:#fff5e9,stroke:#a04d2f,color:#1a1916; classDef ver fill:#ece9e2,stroke:#4a473f,color:#1a1916; classDef ok fill:#dcead0,stroke:#4a7a2f,color:#1a1916; classDef abstain fill:#f4d9d5,stroke:#a03f2f,color:#1a1916; classDef learn fill:#e6def2,stroke:#5a3f8a,color:#1a1916;

If you only remember one picture, that’s it. A query goes in. The cursor reads your library and drafts an answer. The verifier grades it. Only graded answers reach you — everything else comes back as an honest “I don’t know.” And every answer that passes gets written back, so the system gets faster the more you use it.

The three pieces

The cursor — a model you own. It’s deliberately small. It doesn’t memorize the world; it reads. Think of it as a smart pointer that knows how to find the right thing in your library and say it clearly. Small means it runs on a laptop, a mini-PC, or a Pi — no data center, no API bill.

The library — knowledge you curate. This is where capability actually lives. Facts, docs, your work, your domain — organized into packs you can add, grade, and swap. Want the model to know more? Add a pack. No retraining, no fine-tune run, no waiting.

The verifier — the honesty gate. Every draft answer is checked before you see it. If it can’t be grounded in the library, werbos says so instead of making something up. That single rule — abstain rather than bluff — is the whole trust story.

The loop under the hood

Behind the scenes, every question walks the same five steps:

flowchart LR S1["LOOKUP
already known?"]:::s --> S2["SEEK
search the library"]:::s S2 --> S3["COMPUTE
draft an answer"]:::s S3 --> S4["VERIFY
grade it"]:::s S4 --> S5["CACHE
save what passed"]:::s S5 -.->|"feeds the next LOOKUP"| S1 classDef s fill:#fff5e9,stroke:#a04d2f,color:#1a1916;

Look it up, seek it out, work it out, check it, remember it. Learning here doesn’t mean retraining weights — it means writing verified knowledge back into the library. The model stays fixed; the library compounds.

Why this is a different bet

Most AIwerbos
One huge model, rentedA small model you own
Knowledge baked into weightsKnowledge in a library you control
Confidently wrongHonestly abstains
Runs in the cloudRuns on your box, off-grid by default
~$50/day for a 24h agent~$0.03/day — just electricity

That last row is three orders of magnitude, and it’s the whole economic argument: because the model is small and the knowledge is local, werbos can run all day while you sleep for the cost of the power it draws.

Go deeper

  • The Map — what a model is, and the four operations that change it.
  • The Flow — every component a real request passes through, in detail.
  • Compose your model — pick packs and watch your model take shape.
  • See a demo — watch the engine answer, and abstain, live.