I expected the field to fail.
I typed “Facebook, Instagram” into what looked like a plain text field, without selecting anything from a predefined list. In the old world, that would have been useless text. Maybe readable to a human, but not reliable enough for a workflow. In Tana, it became structured intent.
That small moment captured something much larger: even structured data is becoming liquid.
By liquid, I mean an interface that accepts messy human input while still producing reliable structured output. We’ve long prized structured data for its reliability. In the old days, a single typo could break a database connection; that rigidity was both its limitation and its power, creating systems that were rock-solid. But I believe we’re entering an era where generative AI makes even this structure “liquid.” The important point is not that structure disappears. It is that the interface to structure changes.
The schema may still exist underneath, but the user no longer has to speak schema. They can speak naturally, imprecisely, even messily—and AI becomes the translation layer between human intent and machine precision.
The Old Days: Rigid Databases
In traditional databases—SQL, MySQL, even AS400 systems—a single character out of place could break everything. One extra space, a semicolon instead of a colon, a typo in a select option: the whole system would crash. This rigidity was both a weakness and a strength. It forced discipline and created rock-solid, highly reliable systems that performed exceptionally well. Systems like AS400 persisted for decades precisely because of this stability and performance, even if they weren’t the fanciest solutions.
For a long time, this meant users had to conform to the database. The system had the rules, and the human had to learn them: exact field names, exact select values, exact syntax, exact formatting. If you wanted reliable structured output, you needed rigid structured input.
That reliability came at a cost. Every workflow required setup work. Every taxonomy had to be maintained. Every user had to learn the available options. And whenever reality failed to match the predefined categories, the system pushed the burden back onto the human. You either picked the closest option, created yet another category, or abandoned the structure altogether.
How AI Interprets Unstructured Input
Generative AI’s core power lies in roaming through large amounts of unstructured data and making sense of it. But more importantly, it can now take unstructured input—free-form text, casual commands, flexible descriptions—and translate that into precise structured values. This is the fundamental shift: instead of users conforming to rigid schemas, the system adapts to how users naturally express themselves.
This is the old dream of natural-language interfaces to databases becoming practical. For decades, people have wanted to ask systems for things in ordinary language and have the machine translate that into the right query, filter, record update, or structured action. Large language models are finally good enough to make that interface feel natural. They do not eliminate the database; they sit in front of it, interpreting intent and mapping it onto the structure underneath.
A useful way to think about this is as three layers:
- The human layer: messy intent, partial thoughts, shortcuts, ambiguity.
- The AI layer: interpretation, normalization, disambiguation, translation.
- The system layer: structured execution, validation, permissions, consistency.
In older software, the human had to behave as if they were already operating at the system layer. They had to know the fields, the syntax, the categories, the allowed values. In AI-native software, the human can stay at the human layer. The AI handles the translation.
A Concrete Example: Social Posting Workflow
When I set up a social posting workflow, the old way meant using predefined lists. In Notion, I had to create a select field with fixed values: Facebook, Instagram, TikTok, LinkedIn. You clicked the boxes, and it was very structured. But when I moved to Tana, I hit a wall—there were no predefined select options. Instead, I just typed “Facebook, Instagram” or separated them with commas, semicolons, dashes, or pipe symbols. And that was the “aha moment”: it worked. The AI understood what I meant behind the free text, making the precise selections fluidly. The system adapted to my language, not the other way around.
This is a small example, but it points to a much larger shift. The field can still resolve to known channels. The workflow can still depend on structured values. Automation can still route the post to the correct destination. But the user-facing layer no longer needs to be a rigid dropdown. It can be forgiving, interpretive, and human.
The Interface Liquefies, Not the Database
The strongest version of this argument is not that schemas vanish. It is that schemas become less visible to the user. Underneath, systems still need structure, validation, permissions, consistency, and reliable execution. A social post still needs to know whether it is going to LinkedIn or TikTok. A CRM still needs to know which company, contact, deal stage, or next action a note refers to. An accounting system still needs precise categories and amounts.
What changes is where the rigidity lives. In the past, rigidity sat directly in front of the user: fixed forms, select fields, syntax rules, mandatory categories. In the AI-native interface, that rigidity moves downward into the substrate. The user can express intent in a looser way, while the system quietly maps that expression onto the structured model behind the scenes.
So the future is not “no schema.” It is schemas mediated by AI. Database design does not disappear; it moves deeper into the stack. The interface becomes liquid while the operational foundation remains solid.
Why This Matters
The productivity gain is not just fewer clicks. It is that users can capture reality before they have fully categorized it.
This matters because real life rarely arrives in neat database fields. Ideas are half-formed. Notes are messy. Tasks are embedded inside conversations. Customer feedback comes as stories, complaints, screenshots, and fragments. Work starts as language long before it becomes structure.
Rigid systems force users to categorize too early. Liquid interfaces let people capture first and structure later—or let the system infer the structure in the background. That changes the feel of software. It makes tools less like forms to be completed and more like collaborators that understand what you meant.
From Prediction Engines to Practical Reasoning
This shift hinges on a crucial evolution in LLMs. At their core, they’re still prediction engines—word prediction engines. But they’ve become extraordinarily good at it. Whether or not we call it reasoning, the practical effect is that systems can now interpret intent well enough to change interface design.
They can bridge the gap between unstructured thought and structured requirements, and work with liquid data while producing the precise outputs that workflows demand. This is what makes Tana’s behavior possible and what fundamentally changes how we think about data structure. The model does not just see the words “Facebook, Instagram” as text. It can infer that these are channels, normalize them against available options, decide what the user likely meant, and prepare the structured action needed by the workflow.
The Need for Guardrails
There is, of course, a hard edge to all of this: reliability. If AI becomes the translation layer between human language and structured systems, then misunderstandings matter. A model that misreads a note, chooses the wrong account, or maps a vague instruction to the wrong action can create real operational problems.
That means liquid interfaces need solid foundations. They need validation, previews, confirmations, audit trails, and constraints. The system should be flexible at the point of input but precise at the point of execution. The user should be able to speak naturally, but the machine should still verify, resolve ambiguity, and expose uncertainty when it matters.
In other words: liquidity is not the same as looseness. The interface can be fluid because the underlying system remains disciplined.
Redefining Structured Data
Structured data no longer means rigid, predefined slots that users must fit their information into. Instead, it means data that is dynamically structured—adaptable to the user’s language and intent. The definition has inverted: rather than users conforming to the database, the database now increasingly conforms to the user.
This suggests that traditional database design is not becoming irrelevant, but it is being reframed. The most valuable systems will still depend on strong models underneath. But those models will be accessed through softer, more natural surfaces: notes, commands, conversations, free text, and partial descriptions. The structure remains, but it becomes ambient.
The future belongs to systems that can interpret and structure data on the fly, making the interface liquid while keeping the underlying logic sound.
Structured data used to require structured humans. AI changes that. The structure can stay; the human can finally be messy.