Connected Patterns: Data Agents That Do Not Break Production
“The fastest way to lose trust is a query that silently changes the truth.”
Data work is a perfect target for agents, and it is also a trap.
Premium Gaming TV65-Inch OLED Gaming PickLG 65-Inch Class OLED evo AI 4K C5 Series Smart TV (OLED65C5PUA, 2025)
LG 65-Inch Class OLED evo AI 4K C5 Series Smart TV (OLED65C5PUA, 2025)
A premium gaming-and-entertainment TV option for console pages, living-room gaming roundups, and OLED recommendation articles.
- 65-inch 4K OLED display
- Up to 144Hz refresh support
- Dolby Vision and Dolby Atmos
- Four HDMI 2.1 inputs
- G-Sync, FreeSync, and VRR support
Why it stands out
- Great gaming feature set
- Strong OLED picture quality
- Works well in premium console or PC-over-TV setups
Things to know
- Premium purchase
- Large-screen price moves often
It is perfect because data tasks are often repetitive:
• Pull the relevant tables
• Filter by constraints
• Summarize patterns
• Produce a report
• Validate a metric
It is a trap because data systems are full of sharp edges:
• A missing filter can scan a warehouse
• A join can multiply rows and produce plausible nonsense
• A write can corrupt a dataset silently
• A schema change can break logic without errors
• A query can leak private information
A data agent is not valuable because it can write SQL.
A data agent is valuable because it can behave safely while doing useful work.
Safe querying patterns are the design rules that make that possible.
Default to Read-Only Roles
The most important decision is permission.
A data agent should operate under read-only credentials by default.
If it must write, the system should require:
• An explicit role escalation
• A narrow scope
• An approval gate
• A clear rollback strategy
This is the data version of least privilege.
It reduces blast radius before you even start debating prompt quality.
Separate Exploration From Production
Humans often explore in production because it is convenient.
Agents should not.
A safe design separates environments:
• Development for exploration and iteration
• Staging for rehearsal and performance checks
• Production for read-only validation or approved changes
When you cannot fully separate, you can still simulate separation:
• Use read replicas
• Use query governors
• Use row limits
• Use sandbox datasets that mirror shape without containing sensitive rows
The agent should be aware of environment boundaries and refuse to cross them without permission.
The Preview-Then-Commit Pattern
A common failure mode is a query that looks fine and is wrong.
The fix is to make preview a first-class step.
The agent should:
• Draft the query
• Run an explain or dry-run
• Execute a limited preview with strict row limits
• Check for obvious anomalies
• Only then execute the full query when safe
This pattern catches many mistakes early:
• Missing predicates
• Exploding joins
• Wrong time windows
• Unexpected null rates
• Schema mismatch
It also makes review faster. Humans can approve the intent based on the preview rather than trusting an unseen full run.
Guardrails for Expensive Queries
Cost is not only financial. It is capacity.
An expensive query can slow down other users, trigger throttling, or push a warehouse into contention.
Safe data agents enforce query budgets:
• Maximum bytes scanned
• Maximum runtime
• Maximum rows returned
• Maximum concurrency per run
The agent should treat these as constraints, not suggestions.
If the query would exceed limits, the agent should propose alternatives:
• Sampling
• Pre-aggregations
• Narrower time windows
• Partition filters
• Materialized intermediate tables in a safe workspace
Patterns That Prevent Quiet Wrongness
Some errors are worse than failures.
A failed query is obvious.
A query that returns plausible but wrong numbers can live for months.
Safe data agents must defend against quiet wrongness.
Here are patterns that help:
| Pattern | What it does | What it prevents |
|---|---|---|
| Row-count sanity checks | Compares row counts to historical ranges | Silent data explosions and missing data |
| Join cardinality checks | Tests whether joins multiply unexpectedly | Double-counting that looks plausible |
| Null and distribution checks | Samples key fields and compares distributions | Hidden schema changes and parsing errors |
| Reconciliation queries | Cross-checks metrics with an independent method | One-query truth errors |
| Audit columns and lineage | Tracks source tables and transformations | Untraceable results and “where did this number come from” |
These checks do not need to be perfect. They need to be consistent and visible.
Metric Definitions Are Part of Safety
A surprising amount of data work goes wrong because the metric itself is ambiguous.
If “active user” has three definitions across teams, the agent can produce an answer that is correct for one definition and wrong for the question the requester meant.
A safe data agent should treat metric definitions as first-class retrieval.
Before running a query, it should retrieve the definition:
• Which events or tables define the metric
• Which filters apply
• Which time window logic is expected
• Which exclusions exist
• Which version is current
If a metric definition is missing or conflicting, the correct move is to ask or escalate, not to guess.
Time Windows, Time Zones, and the Illusion of Precision
Many data mistakes come from time.
A query can be “correct” and still wrong because the window definition is inconsistent.
Examples:
• A day boundary is UTC in one system and local time in another
• A rolling window includes partial days unexpectedly
• A backfill reprocesses late events and shifts historical numbers
A safe data agent should explicitly state the time assumptions it is using and, when possible, verify them against the metric definition.
When time assumptions are unclear, it should surface that uncertainty rather than hiding it behind precise-looking numbers.
Semantic Layers and Data Contracts
Agents do better when the data model is explicit.
If the organization has a semantic layer or data contracts, the agent should prefer them over raw tables.
A contract tells the agent:
• What a field means
• What values are allowed
• What nulls imply
• What joins are safe
• What the intended grain is
Without contracts, an agent can still succeed, but it must do more verification work to avoid false joins and misinterpretation.
Writing Safely When Writes Are Required
Sometimes data work requires writes:
• Backfills
• Corrections
• Aggregation tables
• Feature tables for modeling
• Materialized reports
If a data agent writes, it should follow strict patterns:
• Write to a new table or partition first
• Validate row counts and distributions
• Compare the new output to a baseline
• Only then promote or swap, under approval
• Keep the old version for rollback
This turns write into stage, validate, then promote.
It also makes failures survivable.
Idempotency for Data Writes
If an agent ever writes, it must be idempotent.
That means the same operation can be applied twice without changing the outcome.
This protects you from retries, crashes, and partial failures.
Idempotency patterns include:
• Writing to a new table with a run identifier
• Using merge semantics rather than blind inserts
• Using unique keys and conflict handling
• Logging the write intent and checking before re-running
A data agent without idempotency is a data corruption generator.
Privacy and Access Boundaries
Data agents must never assume that “if I can query it, I can share it.”
The agent should enforce:
• Output redaction rules
• Aggregation thresholds
• Row-level privacy constraints
• PII detection and masking
If the request might involve sensitive data, the agent should escalate to a human approval gate, even if the query is read-only.
Trust in data work is fragile. Once broken, it is hard to restore.
Verification Gates for Data Outputs
Even read-only queries need verification.
A data agent should treat results as claims that require evidence.
That evidence can include:
• Query text and parameters
• Preview outputs and sanity checks
• Cross-check results
• Source table identities and timestamps
• Metric definition references
The final deliverable should include enough information for someone else to reproduce the result without guessing.
This is how you keep data work honest at scale.
The Agent’s Job Is to Make Review Easy
A safe data agent makes humans faster, not slower.
That means it produces reviewable artifacts:
• The query
• A short explanation of intent
• The preview sample
• The sanity checks performed
• The final output with clear caveats
When review is easy, humans approve quickly and the system remains safe.
The Triage Question: What Kind of Data Request Is This
Support agents triage tickets. Data agents should triage requests.
A practical triage split:
• One-off analysis, where speed matters and reproducibility is still required
• Metric reporting, where definitions and baselines are critical
• Data correction, where writes and rollbacks dominate the risk
• Executive reporting, where clarity and confidence are more important than novelty
If the agent can identify the request type, it can choose the correct safe workflow automatically.
Safe Querying Is the Beginning of Trust
Many teams try to deploy data agents by starting with “write a query.”
A better approach is to start with “write safely.”
If the agent can consistently follow safe patterns, the team will slowly allow it more autonomy.
If it cannot, no amount of clever prompting will save it.
Data is the record of reality inside an organization. That record deserves careful stewardship.
A safe data agent is one that treats truth as something to be proven, not something to be declared.
Keep Exploring Safe Data and Evidence Patterns
• Designing Tool Contracts for Agents
https://ai-rng.com/designing-tool-contracts-for-agents/
• Agent Error Taxonomy: The Failures You Will Actually See
https://ai-rng.com/agent-error-taxonomy-the-failures-you-will-actually-see/
• Verification Gates for Tool Outputs
https://ai-rng.com/verification-gates-for-tool-outputs/
• Monitoring Agents: Quality, Safety, Cost, Drift
https://ai-rng.com/monitoring-agents-quality-safety-cost-drift/
• Agent Run Reports People Trust
https://ai-rng.com/agent-run-reports-people-trust/
• Sandbox Design for Agent Tools
https://ai-rng.com/sandbox-design-for-agent-tools/
Books by Drew Higgins
