Agentic Engineering: Why Companies Fail at AI Agents (And How to Fix It)
DHH reveals why 90% of companies get AI agents wrong—and it’s not because the technology isn’t ready.
The AI agent revolution promised to transform how we work. CEOs envisioned autonomous systems handling customer support, writing code, and managing operations with minimal human intervention. Yet most organizations attempting to deploy AI agents have hit the same wall: expensive failures, frustrated teams, and productivity gains that never materialized.
The problem isn’t the underlying technology. Companies are failing at what industry leaders now call “agentic engineering”—the discipline of designing, implementing, and managing AI agents that actually deliver value. According to David Heinemeier Hansson (DHH), creator of Ruby on Rails and CTO of 37signals, the culprit is a fundamental misunderstanding of what AI agents can and should do.
Act 1: The Fundamental Mistakes in AI Agent Deployment
The Over-Automation Trap
The first and most common mistake companies make is treating AI agents as a complete replacement for human workers rather than as collaborative tools. This “set it and forget it” mentality leads to catastrophic failures.
Consider the case of a mid-sized e-commerce company that deployed an AI agent to handle all customer service inquiries. Within weeks, the system was approving fraudulent refunds, providing incorrect product information, and generating responses that violated company policies. The cost of fixing these mistakes exceeded what they would have spent on human support staff.
The fundamental error was architectural: they designed the agent to operate with complete autonomy in a domain requiring nuanced judgment. DHH calls this “automation hubris”—the belief that because AI can do something, it should do everything.
Successful agentic engineering recognizes that AI agents work best in a human-in-the-loop framework. The agent handles the repetitive, time-consuming work while humans make final decisions on edge cases and exceptions. This isn’t a limitation; it’s a design principle.
Misunderstanding Agent Capabilities
The second critical mistake stems from misaligned expectations about what current AI agents can reliably accomplish. Many companies deploy agents for tasks requiring:
– Deep domain expertise: Agents trained on general data struggle with specialized knowledge
– Long-term reasoning: Multi-step problems spanning days or weeks often exceed agent capabilities
– High-stakes decisions: Situations where errors have severe consequences require human judgment
– Creative problem-solving: Novel situations without clear precedents challenge agent reasoning
A Fortune 500 financial services firm attempted to deploy AI agents for loan underwriting decisions. The agents performed admirably on standard applications but failed spectacularly when faced with non-traditional income sources, complex asset structures, or unusual credit histories. The company had to manually review 40% of applications, negating much of the promised efficiency.
The lesson: agents excel at well-defined, repetitive tasks with clear success criteria. They struggle with ambiguity, novelty, and situations requiring contextual understanding beyond their training data.
The Integration Complexity Problem
The third common failure point is underestimating the engineering complexity of agent integration. Unlike traditional software with predictable inputs and outputs, AI agents introduce non-deterministic behavior into systems designed for determinism.
Companies often deploy agents without adequate:
– Monitoring systems: How do you track agent performance when outputs vary?
– Rollback mechanisms: What happens when an agent makes catastrophic mistakes?
– Version control: How do you manage prompt changes and model updates?
– Security boundaries: What prevents agents from accessing sensitive data or systems?
One healthcare technology company deployed a documentation agent that began accessing patient records it shouldn’t have seen, creating potential HIPAA violations. The issue wasn’t malicious intent—it was poor system design that failed to implement proper access controls for non-deterministic AI behavior.
Act 2: Achieving 10x Productivity Through Proper Implementation
The Focused Scope Principle
Companies that achieve genuine productivity gains with AI agents follow a counter-intuitive approach: they start extremely narrow. Rather than deploying an agent to “handle customer service,” successful implementations target specific sub-tasks.
GitHub Copilot succeeds because it focuses on a precise problem: code completion and suggestion within an IDE. It doesn’t try to architect entire applications, manage deployments, or debug production issues. This focused scope allows it to deliver consistent value.
DHH’s team at 37signals applied this principle when implementing AI agents for Basecamp and HEY. Rather than creating general-purpose assistants, they built agents for specific workflows:
– Email triage agents: Categorize incoming messages and suggest responses
– Code review agents: Identify common issues in pull requests
– Documentation agents: Generate first drafts of technical documentation
Each agent operates within a constrained domain where success criteria are measurable and failure costs are manageable. This approach delivers the mythical 10x productivity gain—but only for the specific tasks the agent handles.
Iterative Refinement Over Perfect Launch
Traditional software development emphasizes thorough testing before deployment. Agentic engineering requires a different mindset: continuous refinement based on real-world performance.
Successful companies deploy agents as “beta” features with explicit human oversight, then gradually expand autonomy as the system proves reliable. This means:
1. Start with suggestion mode: Agent proposes actions; humans approve
2. Move to automatic with review: Agent acts; humans audit results
3. Graduate to autonomous: Agent operates independently for proven scenarios
4. Maintain override capability: Humans can always intervene
A software development agency implemented this approach with code generation agents. Initially, developers reviewed every line of agent-generated code. Over three months, they identified patterns where agent output was consistently reliable—simple CRUD operations, boilerplate code, test scaffolding. These tasks gradually moved to autonomous mode while novel features remained in suggestion mode.
The result: developers spent 60% less time on repetitive coding tasks and 60% more time on architectural decisions and complex problem-solving. This is real productivity transformation.
Human-AI Collaboration Patterns
The most successful implementations don’t eliminate human involvement—they redesign work to leverage both human and AI strengths. DHH emphasizes that agents should amplify human expertise, not replace it.
Effective collaboration patterns include:
The First Draft Pattern: Agents create initial outputs that humans refine. This works for content creation, code generation, and documentation. A technical writing team using this pattern increased output by 3x while maintaining quality standards.
The Research Assistant Pattern: Agents gather and summarize information; humans make decisions. A legal firm deployed agents to analyze case law and extract relevant precedents, reducing attorney research time by 70%.
The Quality Assurance Pattern: Agents check human work for errors, inconsistencies, or policy violations. A pharmaceutical company uses agents to review clinical trial documentation, catching errors that previously required multiple human reviews.
The Escalation Pattern: Agents handle routine cases; exceptional situations escalate to humans. A insurance company’s claims processing agent handles 85% of standard claims automatically, routing complex cases to experienced adjusters.
Act 3: Real-World Examples of Successful Agentic Engineering
Case Study: Shopify’s Agent-Assisted Customer Support
Shopify deployed AI agents to assist (not replace) their customer support team. The agents:
– Analyze incoming inquiries and surface relevant documentation
– Draft response suggestions based on previous similar tickets
– Identify when to escalate to human agents based on sentiment and complexity
Results: Support agents resolve 35% more tickets per day while customer satisfaction scores increased by 12%. The key was positioning agents as tools that make human agents more effective, not replacements.
Case Study: Sourcegraph’s Code Intelligence Agents
Sourcegraph built AI agents that understand entire codebases and assist with:
– Finding where specific functionality is implemented
– Identifying code that needs updating when APIs change
– Generating migration scripts for dependency updates
Their approach succeeded because they focused on augmenting developer capabilities rather than automating development. Developers remain in control while agents handle the tedious work of searching, analyzing, and drafting.
Case Study: Replit’s Agent-Powered Development Environment
Replit integrated AI agents directly into their development workflow, allowing agents to:
– Generate project scaffolding from natural language descriptions
– Debug errors by analyzing stack traces and suggesting fixes
– Explain unfamiliar code in plain language
The critical success factor was transparent agent behavior. Developers always see what the agent is doing and why, maintaining trust and understanding. When agents make mistakes (which they do), developers can quickly identify and correct them.
Framework for Implementation Success
Based on these successes, here’s a practical framework for implementing AI agents:
1. Identify High-Volume, Low-Stakes Tasks
Start with tasks that are:
– Performed frequently enough to justify automation
– Well-defined with clear success criteria
– Low consequence when errors occur
– Currently consuming significant human time
2. Design for Human Collaboration
Build systems where:
– Agents suggest rather than dictate
– Humans can easily override agent decisions
– Agent reasoning is visible and auditable
– Feedback loops improve agent performance
3. Implement Robust Monitoring
Track:
– Agent accuracy and error rates
– Human override frequency and reasons
– Task completion times with and without agents
– User satisfaction with agent interactions
4. Start Small, Scale Gradually
– Deploy to a limited user group
– Gather extensive feedback
– Refine prompts and workflows
– Expand only after proving value
5. Maintain Human Expertise
Ensure:
– Teams understand the underlying processes agents automate
– Humans can perform tasks manually if agents fail
– Domain knowledge remains within the organization
– Career paths don’t dead-end as agents expand
The Future of Agentic Engineering
DHH’s core insight is that successful AI adoption isn’t about replacing humans—it’s about redesigning work. The companies achieving transformative results view agents as team members with specific strengths and limitations, not as magic solutions.
The 10% of companies succeeding with AI agents share common characteristics:
– They start with specific, measurable problems
– They design for human-AI collaboration from day one
– They invest in monitoring and continuous improvement
– They maintain realistic expectations about agent capabilities
– They prioritize transparency and human oversight
The 90% who fail skip these fundamentals, chasing the promise of fully autonomous AI without building the engineering foundations to support it.
As AI capabilities continue advancing, the gap between successful and failed implementations will widen. The differentiator won’t be access to models—those are becoming commoditized. It will be agentic engineering maturity: the organizational capability to design, deploy, and manage AI agents effectively.
For CTOs and technical leaders, the question isn’t whether to adopt AI agents but how to build the engineering discipline necessary for successful adoption. Start small, focus on collaboration over automation, and remember that the goal isn’t eliminating humans from workflows—it’s eliminating the tedious work that prevents humans from doing their best thinking.
The companies mastering this balance will discover that AI agents aren’t just productivity tools. They’re enablers of a new working model where humans focus on creativity, judgment, and strategy while agents handle the repetitive execution that previously consumed so much time.
That’s not a 10x improvement. That’s a fundamental transformation in how knowledge work gets done.
Frequently Asked Questions
Q: What is agentic engineering?
A: Agentic engineering is the discipline of designing, implementing, and managing AI agents that deliver real business value. It encompasses the principles, practices, and organizational capabilities needed to successfully deploy AI agents that augment human capabilities rather than simply attempting to replace workers. This includes understanding agent limitations, designing human-AI collaboration patterns, implementing proper monitoring, and iteratively refining agent performance.
Q: Why do most companies fail at implementing AI agents?
A: Most companies fail due to three fundamental mistakes: over-automation (treating agents as complete human replacements), misunderstanding agent capabilities (assigning tasks requiring deep expertise or high-stakes judgment), and underestimating integration complexity (failing to implement proper monitoring, security, and rollback mechanisms). These failures stem from viewing AI agents as magic solutions rather than as tools requiring careful engineering and human oversight.
Q: How can AI agents actually deliver 10x productivity improvements?
A: Genuine 10x productivity gains come from implementing agents with focused scope on specific, well-defined tasks where they can consistently deliver value. Success requires starting narrow (not trying to solve everything at once), designing for human-AI collaboration (agents suggest, humans decide), and implementing iterative refinement (continuously improving based on real-world performance). Companies achieve these gains by redesigning workflows so agents handle repetitive tasks while humans focus on judgment, creativity, and strategy.
Q: What tasks are AI agents best suited for?
A: AI agents excel at high-volume, low-stakes tasks with clear success criteria and well-defined parameters. This includes code completion, email triage, documentation drafting, data analysis, routine customer inquiries, and quality assurance checking. They struggle with tasks requiring deep domain expertise, long-term reasoning across multiple contexts, high-stakes decisions, creative problem-solving in novel situations, or nuanced judgment based on extensive experience.
Q: Should AI agents operate autonomously or with human oversight?
A: The most successful implementations use a graduated approach: agents start in suggestion mode (proposing actions for human approval), advance to automatic with review (acting independently but with human auditing), and only operate fully autonomously for proven scenarios where reliability is demonstrated. Even then, humans should maintain override capability. The goal isn’t full autonomy—it’s effective human-AI collaboration where each contributes their strengths.
Q: How should companies start implementing AI agents?
A: Start by identifying specific, high-volume tasks that are well-defined, low-consequence when errors occur, and currently consuming significant human time. Deploy agents to a limited user group with extensive human oversight and monitoring. Gather feedback, refine prompts and workflows, and only scale after proving measurable value. Focus on augmenting human capabilities rather than replacing workers, and ensure transparent agent behavior so teams understand what agents are doing and why.
