Your First Agreement — Agreements by Liminate

Start here

You know how sometimes you order food for delivery, and the receipt says one thing but the bag has something else? Like, you ordered a large fry and they gave you a medium. Or you asked for no onions and there they are. Sitting on your burger. Looking at you.

You know what went wrong because you had an expectation — "large fry, no onions" — and the result didn't match. You didn't need AI to tell you that. You just looked at what you asked for, looked at what you got, and made the call yourself.

That's what an agreement does. You write down what you expect. Then when the work comes back — from a person, from an AI, from whatever — the system checks whether it matches. Not by guessing. Not by using another AI. By doing the comparison directly, the same way you'd look in the bag and count the fries.

Let's actually do one

Go to liminate.dev/agreements/app in your browser.

You'll see a page headed "What needs to be checked?" with three questions under it. That's it. Three questions. We're going to fill them in together.

Question 1: "What are you checking?"

This is just a label — a name for what you're looking at. Keep it simple.

Type this:

Delivery order from Friday night

Or whatever makes sense to you. It's just so you can find it later.

Question 2: "What does 'right' look like?"

This is the important one. This is where you describe your expectations. You're not writing code. You're just saying what you wanted.

Type each thing you expected on its own line:

There should be at least 3 items The total should be under 40 dollars There should be no onions

That's it. Three lines. Three expectations. Plain English.

You don't need special words. You don't need to know anything about Liminate. Just say what you wanted.

Question 3: "Who is responsible for this check?"

Who's doing the checking? Just you in this case.

Now click "Build my agreement →"

The system reads what you typed and turns each line into a rule it can check. On the next screen ("Here's your agreement") you'll see something like this:

require items is above 3
    because "There should be at least 3 items"

require total-dollars is below 40
    because "The total should be under 40 dollars"

forbid onions is equal to "yes"
    because "There should be no onions"

Read those out loud. "Require items is above 3." "Require total-dollars is below 40." "Forbid onions is equal to yes." They're sentences. They read like English. And each one keeps your original words after the word because, so you can always see where the rule came from.

A couple of things you'll notice:

The system named the values for you — items, total-dollars, onions — by pulling words out of what you wrote. The exact names depend on your phrasing, so they may not be word-for-word what you'd have picked. That's fine. You'll see them again in a second.
Read each rule literally. "Require items is above 3" means the count has to be more than 3 — so exactly 3 would not pass this rule. If that's not what you meant, this is the screen where you fix it. The rule says exactly what it says; nothing is hidden.

This is the agreement. You just wrote it. The system translated your plain English into rules it can check — but the rules still read like English. That's the whole idea.

Check the boxes and continue

Next to each rule there's a Confirm checkbox. Read each one, make sure it captures what you meant, and check the box. If something doesn't look right, click the rule text to edit it directly.

Once every rule is confirmed, click Approve and continue →

Now it asks: "What actually happened?"

This is the evidence screen. The system is asking you to fill in the actual values — what really showed up in the bag. It asks one plain question per value:

"What's the value for 'items'?" → You ordered at least 3, but only 2 showed up. Type: 2
"What total dollars was reported?" → The receipt says $34.50. Type: 34.50
"What's the value for 'onions'?" → Were there onions? Type: yes

Fill in what actually happened. Not what you wanted — what you got.

Then click Check the work →

The decision

The system compares your evidence against your agreement. For this example, you'd see:

Decision: Blocked

✗items — the rule requires the count above 3; you got 2. NO-GO.

✓total-dollars — the rule requires below 40; you got 34.50. GO.

✗onions — the rule forbids onions; onions were present. NO-GO.

Two rules failed. One passed. The system tells you exactly which ones and why.

No AI decided this. The interpreter just compared what you expected against what you submitted. Like looking in the bag yourself, except the computer did the looking.

Now you get it

That's the whole thing. Every agreement works like this:

Say what you expect (plain English, one line per rule)
The system turns it into checkable rules (you read and confirm them)
Submit the evidence (what actually happened)
Read the decision (what passed and what didn't)

The delivery order example is deliberately simple. But the same four steps work for anything:

"My boss asked me to pull revenue numbers from the earnings release. I want to make sure the AI didn't grab the wrong source."
"I'm reviewing a report and I need to verify that every statistic is cited."
"I wrote a research paper and I want to confirm my sources are all from after 2020."

The rules change. The process doesn't.

The part where it connects to your work

Think about the last time you used ChatGPT or any AI to summarize something, draft something, or pull numbers from somewhere. And then you had that moment: "...is this right though?"

That's the moment Agreements is for.

Before you send the AI off to do the work, you write down what you expect. What source should it use? What should the numbers roughly be? What's not allowed? Then when the work comes back, instead of squinting at it and hoping, you run it through the agreement.

The AI does the work. The agreement checks the work. The agreement doesn't use AI to check — that would be asking the same student to grade their own test. It uses a deterministic interpreter. Think of it like a calculator for rules.

You don't have to use AI data at all, though. You can check anything — a spreadsheet, a report someone handed you, numbers you pulled yourself. If you can describe what "right" looks like, you can write an agreement for it.

When you're ready for your real one

Think of a real scenario from your work. Something where you've had to check numbers, verify sources, or make sure a report met certain criteria. Then go to liminate.dev/agreements/app and try it.

Some ideas to get you started:

"The revenue in this summary should match the 10-K filing, and the source better be EDGAR, not some random blog."
"This client's blood pressure readings — flag anything above 140."
"This research paper needs at least 800 words, sources after 2020, and no Wikipedia."

Whatever you pick, the process is the same: say what you expect, review the rules it builds, submit the evidence, read the decision. And read the rules it generates — they're in plain English on purpose, so you can always confirm the system understood you before anything runs.

One more thing

If you want to use ChatGPT or Claude to help you think through your requirements, you can paste this whole document into the chat and say:

"I'm trying out Liminate Agreements. Here's how it works. I want to create an agreement for [your scenario]. Help me write the requirements — one per line, plain English."

The AI can help you think about what to check. Then you take those requirements to liminate.dev/agreements/app and let the system do the rest. The AI helps you think. The interpreter checks the work.