From coding to Knowledge work agents — Karan Vaidya, Composio
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
3:55
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
20:00
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
235s
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
320s
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
570s
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
820s
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
1035s
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
1120s
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.
Mentioned resources
Channel & topics
Watch on YouTube · Back to latest
This independent, AI-assisted summary is provided for commentary and informational purposes. It may contain errors or omit important context. Please watch the original video for the creator's complete presentation. Video, thumbnail, and related copyrights belong to their respective owners.