Why Coding AI Agents Outperform Knowledge Work Agents

AI agents are currently demonstrating significant advancements, primarily in software engineering. Most agentic tool usage today is concentrated within this field, with other types of work trailing far behind. Karan Vaidya, CTO of Composio, points out this disparity as a critical area for understanding the current state of AI agent development.

Systems like Git, CI/CD, and linters were already designed for automation, making coding environments inherently 'agent-ready.' Karan Vaidya emphasizes that this pre-existing infrastructure is what enabled AI agents to flourish in the coding domain.

Building these foundational elements is crucial to extend AI agent capabilities beyond software development. The first of these critical pillars is centralization.

Coding agents thrive because they operate within a central repository, like a codebase, where all necessary information is readily available in a single place. In contrast, knowledge work is highly fragmented, with crucial data scattered across numerous applications such as Salesforce, Notion, and Slack. This dispersion forces knowledge work agents to spend significant time and effort manually piecing together disparate information, hindering their efficiency. Without a unified source of truth, agents struggle to perform complex tasks effectively across different platforms.

In coding, Git automatically provides a complete historical record of every change, allowing agents to understand past decisions and even revert errors. This built-in history is crucial for an agent's ability to learn and adapt. Knowledge work, however, typically lacks such a comprehensive record, meaning agents must start from a blank slate with each new task, unable to leverage previous experiences.

Information in knowledge work environments is often spread across hundreds of different applications. Crucially, none of these applications maintain a unified historical record of actions or data. Consequently, agents operating in knowledge work lack memory and are forced to start from a blank state almost every time, unable to learn from past successes or failures.

There is no built-in mechanism to confirm whether the task was actually done correctly or effectively. This fundamental absence of a clear record of work makes it difficult to hold agents accountable or to trust their outputs.

Centralized logging allows every action an agent takes, across all touched applications, to be recorded. This includes what the agent interacted with, what it skipped, and what ultimately worked or failed. This comprehensive logging system provides agents with a vital memory, enabling them to understand and replicate successful task patterns. Furthermore, these logs offer crucial transparency for users, allowing them to identify and address errors early in the process, fostering greater trust in agent performance.

The 'map' refers to the platform's architecture and how information flows between different components, providing an objective understanding of the system. The 'style' pertains to the company's specific preferences and unwritten rules, such as coding standards enforced by linters or preferred decorators, which dictate what 'good' looks like within that organization. Coding agents naturally access both of these dimensions directly from the codebase, allowing them to understand not only the functionality but also the desired operational nuances.

Centralized logging effectively creates a detailed map of how an organization operates, distilling successful approaches and identifying common failure modes. This system works at three distinct levels: how a tool generally functions, how a company specifically utilizes that tool, and individual user preferences. By capturing this comprehensive operational intelligence, agents no longer have to guess organizational preferences, enabling them to align their actions more precisely with company standards and individual user needs.

The moment an agent writes code, a series of automated checks immediately follow. Unit tests catch small, localized mistakes, while integration tests identify errors that impact components further downstream. Compilers and linters enforce structural and stylistic standards, creating a closed loop where agents can validate their own output against predefined criteria, significantly enhancing reliability.

Autonomous agents in real-world scenarios often lead to disastrous outcomes because current testing methods fail to verify the necessity or appropriateness of an action. For example, an AI agent might send out emails that are technically valid with real addresses, yet critically damage the user's reputation because there was no test to question whether the action should have occurred at all. In the absence of robust internal verification, the internet itself becomes the feedback loop, often after the damage is already done. This gap in assessing the true impact and intent of actions highlights a significant flaw in how agents are currently deployed outside controlled coding environments.

Relying solely on prompting is insufficient for controlling AI agents, as even an AI alignment director from Meta mistakenly lost 200 important emails due to fragile prompt-based constraints. Software development, in contrast, uses structural governance through Git branches and code owners to limit the blast radius of agent actions, ensuring changes are reviewed and approved. True governance requires multiple layers of constraints and structural walls around agents, rather than a single, easily bypassed gate. This inherent lack of robust boundaries makes knowledge work agents hard to trust, not because they are inherently worse than coding agents, but because they operate in an environment without these protective measures.

Current permission systems across various applications are too fragmented and scattered to enforce robust governance for AI agents. Instead of relying on fragile prompts, deterministic control over what an agent can access and do is essential. This means defining boundaries outside the agent's memory, ensuring that a hiring agent, for example, can only read emails, while a support agent can draft an email but not send it. Such properly scoped access prevents agents from inadvertently or intentionally crossing critical operational lines, providing a much stronger layer of control and security.

Natural language policies can be used to control agent actions, specifying preventive rules such as limiting email deletions or restricting access to certain domains. This combined approach ensures real governance by enforcing what an agent can do, rather than merely asking it to behave, thereby enhancing safety and reliability.

The final pillar is reversibility, which becomes critical when things go wrong: the ability to undo actions. In coding, almost every change is recorded and can be walked back, making it relatively safe to experiment and correct mistakes. In contrast, many actions in knowledge work, such as deleting emails or initiating wire transfers, are permanent and lack an 'undo' button. This fundamental difference in reversibility significantly alters the risk profile, making knowledge work inherently less forgiving than coding.

In coding, there's a concept of 'trust after the fact,' where actions can be run, checked, and undone if necessary. However, in knowledge work, most actions lack an undo button, making errors largely irreversible. This absence of reversibility significantly changes the entire equation, expanding the 'blast radius' of failure and making mistakes in knowledge work feel far more dangerous than those in coding.

To mitigate the risks associated with irreversible actions in knowledge work, such as hard deletes that permanently remove emails, sandboxes are crucial. An agent can first perform actions within a sandbox environment, allowing users to review and approve them before they are pushed to the production environment. This approach reverses the timing model, enabling mistakes to be caught and corrected proactively, before any real-world consequences occur, rather than reacting to errors after they have happened.