goagentdata

Minsky's frames, 1974: the idea your data agent is missing

TL;DR. In 1974 Marvin Minsky argued that people understand a new situation by pulling a remembered structure, which he called a frame, and adjusting the details. A frame has slots, a default for each slot, and room for known exceptions. An AI agent reading your tables has a generic frame from its training, not yours. It sees column names and guesses what a row means. Write one short frame card per important table, and tell the agent to stop and ask when a row fits nothing on it.

A frame for the orders table, and four rows meeting it A frame card for orders lists four slots with their defaults: one row is an order attempt, amount above zero, currency USD, a real customer. Four rows arrive. Row A fits every slot. Row B comes from a test account: a known exception, set aside, the frame stays. Row C is a refund: a known exception, netted against revenue. Row D is in euros: no slot accepts it, and the frame says to stop and ask a person. Illustration of Minsky's 1974 idea, not measured data. The frame: orders what a person already expects one row isan order attempt amountabove zero currencyUSD customera real one Defaults hold until a row says otherwise. A dana@shop.co 120 USD paid fits every slot B qa@ourco.com 50 USD paid known exception:test accountset aside, frame stays C li@mail.com -80 USD refunded known exception:refundnetted against revenue D eva@mail.de 150 EUR paid no slot fitsstop and ask
After Minsky, 1974: a frame, its defaults, the exceptions it can explain, and the row it cannot. Illustration, not measured data.

What did Minsky propose?

Marvin Minsky co-founded the AI lab at MIT. In June 1974 he wrote a memo called A Framework for Representing Knowledge. In a two-minute interview clip from 2011 he explains the name himself. His starting point was that people do not reason from scratch. When you open the door to a room you have never seen, you already expect walls, a floor and a ceiling, and you notice only what breaks the pattern.

He called that remembered structure a frame. A frame has a top part that is always true, and slots that get filled for each case. Each slot has conditions on what may fill it, and a default used until something better arrives. When something does not fit, you can find an excuse: a chair that is too small still fits the chair frame if it is a toy, so you keep the frame and note the exception. When nothing explains the mismatch, you switch frames. Drawing on a colleague's work, he added that checking effort scales with the stakes: a desk gets a glance, a unicorn gets a close look. He also called a frame "a collection of questions to be asked" about a situation, and said plainly that the theory was incomplete.

Why does a 1974 idea matter now?

Frames went on to become a standard part of the expert-system software of the 1980s. I think those systems faded because every frame had to be written by hand, and language models now learn their frames from text instead.

The problem frames solved did not go away. An agent that answers questions about your data reads tables the way a new hire reads them on day one: it knows the words, not your business. Industry analysts at Forrester warned in 2026 that agents without explicit context get joins wrong and misread metrics. AI engineers describe rediscovering ontologies to fill the gap, and much of that writing comes from people who sell the machinery.

I think a startup does not need an ontology. It needs the frame a good analyst carries in their head, written down for the few tables your key numbers come from.

What does a frame look like for a data table?

Take an orders table. A person who knows the business reads it with a frame already loaded. One row is an order attempt by a real customer, and only paid ones count as revenue. The amount is above zero and in dollars. Test accounts, refunds and orders not yet paid are known exceptions. Revenue deserves a close look, because the board sees it.

The agent has none of this unless someone writes it down. Picture a startup where the engineers test checkout with company email addresses. The agent sums the amount column, the test orders are inside, and the founder quotes a revenue figure about four times too high, as in the test below.

A small test: does a frame card change the answer?

I ran this on 20 November 2026 with eight made-up orders and one question: what was our revenue in October? The correct answer, computed in SQL, is 320 dollars, plus one euro order that a person should look at. I asked an open model from OpenAI, gpt-oss-120b on Cloudflare Workers AI, three times with the table alone and three times with a frame card above it.

Without the card, all three answers counted the two test accounts and came to 1,369 or 1,449 dollars, more than four times too high. With the card, two answers came to 320 dollars and listed what was left out and why. The third stopped and asked what to do with the euro order, which is what the card told it to do. A smaller model, Llama 4 Scout, also left the test accounts out once it had the card, but it got the sums wrong and never stopped to ask.

Three runs per case is a direction, not a measurement. It shows two things: the card changes what gets counted, and the sums should run in SQL rather than in the model's head.

What goes on the card?

Each part of the card answers one failure.

The default meaning. Failure: the agent counts what a row looks like, not what it is. Guardrail: one sentence at the top of the card says what one row is. Check: ask the agent what one row in the table is, and compare.

The known exceptions. Failure: test accounts and refunds go into customer numbers. Guardrail: list each exception and what to do with it. Check: run the query below and look at the exception counts.

When to stop. Failure: a row that fits nothing is dropped or guessed. Guardrail: a rule that such rows go to a person, and a query that counts them. Check: the count of rows that fit no slot is reported with every answer.

How much checking. Failure: a board number gets the same care as a page view count. Guardrail: name the high-stakes numbers on the card. Check: for those numbers the agent shows its query.

What changes by stage?

Whether an agent answers data questions at all matters more here than stage. With no agent, a person carries the frame and this can wait.

Before launch. You have one or two tables and no agent asking questions yet. Write the default meaning as a comment on the table and stop.

First paying customers. Write cards for the tables your revenue and active-customer numbers come from, usually orders, customers and subscriptions.

Growing, with a first data person. That person owns the cards, adds exceptions as they are found, and turns the stop rule into a check that runs every day.

For your data team

For your data team

This part gets technical. The card is a markdown file in your repository, next to the agent's instructions file:

# orders: frame card
One row is: one order attempt by a customer. Revenue counts only paid orders.
Default: status paid, amount positive, currency USD, a real customer.
Known exceptions (keep the frame, leave the row out of revenue or net it):
- Emails ending @ourco.com are our own test and internal accounts. Leave them out of every customer number.
- status refunded: a refund of an earlier order, amount is negative. Subtract it from revenue in the month it happens.
- status pending: not paid yet. Not revenue.
Stop and ask a person when a row fits none of the above, for example a currency other than USD. Do not convert or guess.
Stakes: revenue is a board number. State what you excluded and why.

That is the card from the test, word for word. I would add one line the test did not cover: "Run SQL for every number; never add numbers yourself."

The same frame as a view, on PostgreSQL 16, so the exceptions and the stop rule are counted, not remembered:

create view orders_frame as
select o.*,
  case
    when lower(customer_email) like '%@ourco.com' then 'exception: internal or test account'
    when currency is distinct from 'USD'           then 'no slot fits: currency'
    when status = 'refunded'  then 'exception: refund'
    when status = 'pending'   then 'exception: not paid yet'
    when status = 'paid' and amount > 0 then 'fits'
    else 'no slot fits: other'
  end as frame_match
from orders o;

select frame_match, count(*), sum(amount)
from orders_frame group by 1 order by 1;

On the test data the naive sum was 1,579 dollars. The view gave 400 dollars of orders that fit, an 80 dollar refund, and one euro row to ask about, which makes 320 dollars of revenue. Put the stop rule for currency before the exceptions, because the first match wins: a refund in euros must go to a person, not be netted as dollars. The lower() and is distinct from catch capital letters and empty currencies. Point the agent at the view, not the raw table, and have it report the "no slot fits" count with every revenue answer.

Check it in 10 minutes

  1. Ask your agent what one row in your orders table is. If the answer is vague, write the one-sentence default meaning.
  2. Ask how many orders came from your own team's email addresses this month. If the number is not zero, add that exception to the card.
  3. Ask for last month's revenue and how it was counted. If the agent added the numbers itself, tell it to run SQL.
  4. No coding agent and no repository? This step is for you. Paste the card above into the instructions of the AI tool your team uses for data questions, with your own email domain and statuses, and ask the same question again.
  5. The person who answers for revenue in board meetings owns the card.

See where your setup stands with the two minute self-check. The day-one metric post shows how test accounts distort the first number you track.

Spotted a mistake or a newer source? Tell us and we check it against the source. How we work.

Check your setup in 2 minutesAll postsGet new posts by email