# From coding to Knowledge work agents — Karan Vaidya, Composio

## Executive summary

The presentation argues that while autonomous AI agents have excelled in software engineering due to inherent infrastructure support (e.g., Git history, CI/CD), knowledge work agents are currently limited because they lack comparable foundational systems. The speaker identifies six critical primitives—Centralization, History, Context, Verification, Governance, and Reversibility—that must be built into the enterprise layer to enable reliable AI agents for fields like sales and support.

## Key takeaways

- The Infrastructure Gap: Coding agents benefit from infrastructure (repo, commit history, tests, CI/CD) that was designed for automation. Knowledge work lacks this surrounding system, causing agents to operate 'blind' when applied outside of code bases.
- Centralization is Key: Knowledge work data is typically scattered across multiple platforms (e.g., Salesforce, Notion, Gmail, Slack). Agents require a single source of truth—a centralized layer—to pull all necessary threads and connections before they can operate effectively.
- The Six Missing Primitives: To bridge the gap between coding agents and knowledge work agents, six primitives must be built: Centralization (single data source), History (record of past actions), Context (organizational map + style guide), Verification (pre-action checks), Governance (deterministic boundaries/walls), and Reversibility (undo capability).
- Failure is Permanent in Knowledge Work: Unlike code, where changes can be reverted or walked back, many knowledge work actions (sent emails, wire transfers) are irreversible. This shifts the risk profile, requiring agents to check their work *before* executing any destructive action.

## Technical details

- Centralization and Data Silos: A single deal's information is often scattered across five separate platforms (Salesforce, Notion, Gmail, Slack, Zendesk), lacking a unified source of truth. The solution requires building a central layer to aggregate all app connections and data points for the agent.
- History and Memory Layer: In code, Git provides an automatic record of every change. For knowledge work, agents start with no memory. A dedicated logging layer must be built on top of centralized data to log every action taken by the agent across all connected apps, providing both memory for the agent and auditability for humans.
- Contextual Intelligence: Two types of context are needed: 1) The platform map (how data flows/architecture); and 2) Style (the unwritten rules or 'what good looks like,' such as specific linter rules). This requires aggregating information across tools to build a comprehensive operational playbook.
- Verification and Sandboxing: Code agents are protected by unit tests, type systems, and linters. For knowledge work, verification must happen *before* action. Implementing sandboxes allows the agent to test destructive actions (like sending emails) in a mock environment before hitting the real world, minimizing the blast radius.
- Governance and Boundaries: Instead of relying on fragile prompts or permissions, governance requires building deterministic walls outside the agent's memory. This involves defining explicit access controls (what it can reach) and natural language policies (how it must behave), ensuring compliance even if the agent forgets its instructions.
- Reversibility vs. Prevention: Since many knowledge work actions are irreversible, the focus shifts from 'undoing' mistakes after they happen to preventing them entirely by forcing agents through a review/sandbox process before execution.

## Practical implications

- Organizations must shift focus from solely improving LLM models to building the underlying infrastructure (the 'substrate') that connects, logs, and governs data across disparate enterprise applications.
- Implementing a centralized logging/record layer is crucial for giving agents memory and auditability in knowledge work processes.
- Adopting sandboxing techniques for high-risk actions allows organizations to test agent behavior safely before deployment into production environments.

## Topics

AI Agents, Enterprise Architecture, Software Engineering, Data Governance, CI/CD, Karan Vaidya, Composio

Source: https://www.youtube.com/watch?v=xxfMT-bPEmU