If there is one thing this proof of concept makes clear, it is this:
GenAI is not constrained by model capability. It is limited by the quality of your business metadata.
I built a small SQL agent as an experiment. Nothing enterprise-grade. Just SQLite, a synthetic sales dataset, and an agent loop with three tools:inspect schema, read the data dictionary, and execute SQL.That is it!
The twist was intentional. The schema used cryptic column names like geo_c, chn_x, st_f, sku_z, cst_r, u_n, and v_n. The kind of naming conventions you see everywhere in real systems. No semantic layer. No friendly labels.
The only thing I added was a proper data dictionary. Clear definitions. Valid values. Examples. Basic governance discipline.
Then I asked a simple business question:
“Using the sales table, give me the best sold product and tell me who is the best customer. Exclude refunded transactions.”
What happened next is what makes this interesting.
The agent did not guess. It did not hallucinate column meanings. It first inspected the schema. Then it pulled the data dictionary to understand what each column represented. It mapped st_f to status (P = Paid, R = Refunded), u_n to units sold, v_n to net sales, sku_z to product, and cst_r to customer.
It generated SQL and attempted execution.
On the first pass, it tried to execute two statements in a single call. The database rejected it with: “You can only execute one statement at a time.”
Instead of failing, it adapted. It split the logic into two separate queries, reran them independently, and returned the correct results.
There was no custom retry logic. No special error handler coded for this scenario. Just reasoning over tool feedback and adjusting behavior.
That self-correction is not the most important part, though.
The most important part is that the agent could reason correctly because the metadata was trustworthy.
Without clear definitions, the agent would have guessed. And confident guessing at scale is dangerous. With governed metadata, the same model becomes reliable.
This is the point many GenAI strategies miss.
AI does not replace data governance. AI amplifies it.
If your definitions are inconsistent, undocumented, or outdated, GenAI will scale confusion across your organization. If your metadata is clean and governed, agentic AI becomes a reasoning layer on top of your enterprise data.
This POC is intentionally simple:
- SQLite
- ~135 rows
- A small agent loop
- No enterprise platform
And yet it demonstrates natural language to SQL, schema introspection, metadata-driven reasoning, runtime self-correction, and fully auditable SQL execution.
The code is here:https://github.com/santiagodsm/sql-agent-loop
The real takeaway is not the tool. It is the foundation.
If we want GenAI to scale safely and exponentially inside enterprises, the starting question is not “Which model should we use?”
It is:Do we trust our metadata?
