Enterprise AI Agents Have a Reliability Problem, But What Does That Really Mean?

Most enterprise AI agents are failing because they’re unreliable, bot because they’re unpopular. After surveying a slew of 2025 reports and adoption data, the post shows a consistent picture: off-the-shelf tools like Copilot and ChatGPT are used widely, but custom, first-party AI agents almost never make it past pilot. Organizations think they want automation, but when agents actually execute workflows that matter (with correctness, consistency, and resilience) they fall short. Developers are responding by dialing down ambition: simpler agents, shorter action sequences, and heavy human oversight, precisely because reliability is the gating factor.

Employees won’t adopt systems they can’t rely on, and that’s where a lot of internal AI pilots stall. The gap between off-the-shelf adoption and custom agent rollout mirrors larger AI maturity challenges: poor governance, inadequate testing frameworks, and a lack of robust observability into autonomous workflows.

The smart play is to engineer for trustworthy autonomy (tighter scoping, formal correctness checks, and iterative expansion instead of full-scope rollout).

Continue Reading.

The Hidden Risk of AI-Generated Integration Code

Integration code sits at the seams between systems, APIs, schemas, and contracts, which makes it brittle even when written by experienced engineers. This article lays out pragmatic best practices: constrain AI to well-defined tasks, enforce strict input/output schemas, require human review, and treat AI-generated code as untrusted by default. AI can accelerate glue code, but only when teams design guardrails that acknowledge how little context models actually have about downstream dependencies and failure modes.

Integration code has become the largest source of production instability in data and analytics platforms (especially as teams connect SaaS tools, event streams, and AI services at speed). AI makes this worse if you let it freestyle. A model doesn’t know which API calls are idempotent, which retries will duplicate data, or which schema changes will cascade into broken dashboards.

The right strategy isn’t “AI writes the code”. Think of it more like “AI assists inside a controlled contract.” Strong typing, schema validation, test harnesses, and CI gates matter more here than anywhere else.

Continue Reading.

Why AI Coding Agents Still Can’t Be Trusted in Production

Coding agents struggle with brittle context windows, incomplete understanding of system state, and an inability to reason reliably across large, evolving codebases. They can scaffold features, refactor isolated files, or generate boilerplate, but once tasks span multiple services, repos, or long-lived architectural decisions, failure rates spike. The article argues that today’s agents are fundamentally constrained by how context is loaded, retained, and validated (making them impressive demos but risky operators).

We’ve seen agents perform well in greenfield experiments, then quietly fall apart when introduced to legacy code, undocumented dependencies, or real-world CI/CD constraints. This mirrors what happens in data engineering and analytics: tools that work on clean samples fail in messy production environments. Until agents can reason over full system context (schemas, contracts, historical decisions, and runtime behavior), they’ll remain assistants, not engineers.

The smart strategy right now is augmentation, not delegation. Use agents to accelerate well-scoped tasks, but keep humans responsible for system-level coherence.

Continue Reading.

The Three Durable Function Patterns Every Distributed System Relies On

There are only three durable function forms that reliably show up in distributed systems. He breaks them down as append-only logs, mutable state with coordination, and deterministic replay (each with distinct tradeoffs around consistency, recovery, and scalability). Rather than framing durability as a storage concern, this article reframes it as a function design problem: how state transitions are recorded, recovered, and reasoned about over time.

Most reliability issues aren’t caused by outages, they’re caused by incorrect assumptions about durability. Tteams mix paradigms unintentionally: treating logs like mutable state, or assuming replay semantics where none exist. That’s how you end up with broken reprocessing, corrupted metrics, or AI pipelines that can’t be audited.

Whether you’re building on Kafka, Iceberg, Delta, or workflow tools like Temporal, understanding which durable function you’re actually using (and why) should be a first-order architectural decision.

Continue Reading.

Why Most Generative AI Use Cases Fail Before They Start

Teams are chasing what’s possible instead of what’s valuable. Rather than starting with models or tools, the article argues for anchoring generative AI initiatives in clear business constraints (where variability is high, human judgment is expensive, and outcomes can be measured). It distinguishes between tasks that benefit from generative flexibility (drafting, synthesis, exploration) and those that demand determinism and control (transactions, compliance, core operations). The result is a simple but often ignored message: most failed GenAI projects were use-case selection failures.

Chatbots get built where workflows should be automated. Summarization tools get deployed where data quality is the real issue. MIT Sloan’s framework is valuable because it forces discipline: match AI to uncertainty, not to hype.

If your data isn’t reliable, observable, and well-modeled, generative AI will amplify confusion, not insight.

Continue Reading. 

How Data and AI Are Reshaping Productivity in Banking and Payments

Banks and payment providers are using data and AI to unlock productivity gains in an industry historically slowed by legacy systems and regulatory friction. This article highlights concrete use cases (fraud detection, real-time risk scoring, customer personalization, and operational automation) powered by unified data platforms and machine learning at scale. Rather than treating AI as a bolt-on innovation lab experiment, leading institutions are embedding it directly into core workflows, using lakehouse architectures to break down silos between transactional data, analytics, and AI models.

Banking teams don’t get the luxury of “good enough” data. (latency, lineage, and governance are non-negotiable). The same patterns show up in retail, healthcare, and SaaS:. Productivity gains come not from flashy models, but from consolidating platforms, standardizing data products, and operationalizing AI end-to-end.

Databricks’ framing also reinforces that AI impact scales fastest when it’s built into the data platform itself, not layered on top as a separate system.

Continue Reading.