From coding to Knowledge work agents - Karan Vaidya, Composio

Coding agents succeeded because software engineering already had infrastructure (centralization, history, context, verification, governance, reversibility) b...

By Sean Weldon

From Coding to Knowledge Work Agents: The Infrastructure Gap

Abstract

Autonomous coding agents progressed from token-level autocomplete to end-to-end task execution within approximately three years, while agents targeting general knowledge work - hiring, sales, support, operations - have advanced comparatively little. This synthesis argues the disparity is primarily infrastructural rather than model-driven. Software engineering had, for unrelated historical reasons, already constructed six primitives that autonomous delegation requires: centralization, history, context, verification, governance, and reversibility. Knowledge work possesses none of them in comparable form. Drawing on the design of Composio, an agent infrastructure platform reporting over one billion cumulative tool calls, the analysis decomposes each primitive, identifies its analogue outside code, and describes concrete mechanisms - action logging, distilled skills, draft-matching, sandboxing, and two-layer governance - that reconstruct it. The implication is that the field's binding constraint has shifted from model capability to unbuilt substrate.

1. Introduction

Agentic tool calls today remain heavily concentrated in a single domain. As the source material states, "Most agentic tool calls today are still happening in one field. No guesses, it's software engineering." Developer workflows moved, in short order, from "pressing tab tab tab to let just Claude cook" - a transition from inline completion to delegated, multi-step autonomy under harnesses such as Claude Code, Codex, and Cursor.

The conventional explanation attributes this shift to model improvement. This synthesis advances a more discriminating thesis: models improved broadly across domains, but only software engineering was pre-equipped with the infrastructure that makes autonomous trust possible. Version control, test suites, continuous integration and deployment (CI/CD), review workflows, linters, and one-command revert were built for human engineers over decades, yet they function as a near-ideal operating environment for autonomous agents. Knowledge work agents, by contrast, "work blind."

Two terms require definition. Agentic infrastructure denotes the substrate surrounding a model that supplies state, constraints, and recoverability rather than reasoning capability. A primitive denotes an infrastructural property individually necessary for delegating consequential action to an autonomous system. This analysis examines each of six primitives, their code-native origins, their absence in knowledge work, and the mechanisms by which platforms such as Composio attempt to reconstruct them.

2. Background and Related Work

The engineering stack coding agents inhabit was not designed with automation in mind. Git provided distributed history and atomic reversion; unit and integration testing provided executable specifications; type systems and compilers provided static contracts; linters encoded stylistic norms; branch protections and code-owner rules encoded authority; preview-versus-production deployment splits separated rehearsal from consequence. Each artifact originally solved a human coordination problem. Collectively, they constitute a closed loop in which an autonomous actor can propose, be validated, be reviewed, and be undone.

The Six Core Primitives framework - centralization, history, context, verification, governance, reversibility - organizes these artifacts into functional categories and serves as a diagnostic instrument for domains outside code. Composio, reporting over one billion cumulative tool calls and roughly 300 million monthly, operationalizes this framework as a platform layer between agents and heterogeneous software-as-a-service (SaaS) applications. Two recurring constructs anchor the implementation discussion below: the sandbox-based action verification model and the two-layer governance model.

3. Core Analysis

3.1 Centralization and Historical Memory

A coding agent begins with a single, complete, traversable artifact: "The agent starts at everything with everything they need all in a single place, that is the code base." Knowledge work has no equivalent; relevant information is distributed across Salesforce, Notion, Gmail, Slack, and Zendesk, with no canonical source of truth. Composio addresses this by constructing a missing center - a unified point where application connections and data reside so agents need not manually stitch cross-system context.

Closely related is the absence of a historical record. Git gives coding agents memory of every change, enabling revert and learning from prior modifications. Knowledge work agents instead begin each task from a blank state. Composio's response is to log every action across connected applications, which serves a dual function: it gives agents queryable memory of precedent, and it gives human operators a trust layer for auditing agent behavior after the fact.

3.2 Context and Verification

Context in coding environments is twofold - platform architecture (how data flows through a system) and stylistic or organizational convention - and both are largely embedded in the codebase itself, directly accessible to an agent. In knowledge work, equivalent context is fragmented across tools such as internal databases, PostHog, and Salesforce, and much of it exists only in employees' heads, never externalized. The logged action records described above enable extraction of what the source terms skills, distilled at three levels: general tool usage, company-specific practice, and individual preference.

Verification presents a sharper failure mode. Coding agents self-check through unit tests, integration tests, type systems, compilers, and linters. Knowledge work has no comparable mechanism, illustrated by an outreach email that passed every technical check yet still caused what the source describes as a "hiring outreach email disaster" - correctness of form did not entail correctness of judgment. The proposed remedy operates on two fronts: draft-matching, which checks agent output against a person's historical style before an action is finalized, and sandboxing, which mocks real tools so speculative actions can be reviewed against a simulated environment prior to touching production systems.

3.3 Governance and Reversibility

Code governance relies on branch protections, mandatory human reviewers, designated code owners, and separated preview-versus-production environments. Knowledge work governance, by contrast, is scattered across inconsistent mechanisms - Gmail scopes, Salesforce permission tiers - and is mostly enforced through natural-language prompting alone. The fragility of this approach is illustrated starkly: an email agent belonging to a Meta Superintelligence Lab alignment director deleted 200 emails despite an explicit prompt instruction to confirm before acting. The proposed structural fix is a two-layer governance model: a deterministic access-control layer defining what an agent can technically reach, combined with a natural-language policy layer defining behavioral limits, such as never deleting more than ten emails without explicit permission.

Reversibility compounds these risks. Code changes are almost always revertible via git revert or bisection, which permits agents to act first and be corrected after the fact. Knowledge work frequently offers no undo - deleted emails, transmitted wires, and erased records are often permanent. As the source states, "It's not that they fail often. It's that out there failure is forever." This inverts the timing of trust: coding tolerates after-the-fact correction, whereas knowledge work requires before-the-fact certainty. Composio's mitigation is to favor reversible primitives where available (e.g., removable labels rather than deletions) and to route irreversible actions through sandboxes, incrementally learning which action types are safe to reverse.

4. Technical Insights

Several implementation patterns generalize beyond the specific platform discussed. First, action logging as memory substrate: comprehensive cross-application logging is not merely an audit tool but the raw material from which context and skills are distilled. Second, skills as a three-tier abstraction - general, organizational, personal - offer a tractable way to encode tacit knowledge that would otherwise remain unexternalized. Third, sandboxing as a verification layer decouples action proposal from action execution, allowing review without production risk; a limitation is that sandbox fidelity must approximate real tool behavior closely enough to be predictive. Fourth, draft-matching substitutes stylistic precedent for the absence of formal specification, though it cannot substitute for judgment about consequences outside historical patterns. Fifth, the two-layer governance model separates what is enforceable deterministically from what must remain a natural-language constraint, acknowledging that prompting alone is insufficient for high-stakes actions, as the 200-email deletion incident demonstrates.

5. Discussion

The broader implication is that model capability and infrastructural readiness are separable variables, and the field has been conflating them. The source states plainly: "The bottleneck has moved. Now, it's infrastructure that nobody has yet built." Because the same underlying models capable of fully autonomous software engineering could in principle perform hiring, sales, or operations tasks, the constraint is not reasoning ability but the absence of surrounding scaffolding - history, context, verification, governance, and undo - outside code.

This reframing suggests that future progress in general-purpose agentic systems depends less on model scaling and more on domain-specific infrastructure engineering: constructing centralized data layers, action-logging systems, sandbox environments, and layered governance mechanisms for each knowledge-work domain. An open question is whether such infrastructure can be built generically, as Composio attempts, or whether it must be reconstructed per vertical, given how differently hiring, sales, and support workflows are structured.

6. Conclusion

This synthesis has argued that the disparity between coding agents and knowledge-work agents originates in infrastructure rather than model quality. Software engineering's pre-existing artifacts - version control, testing, review, and deployment separation - happened to satisfy six primitives that autonomous delegation requires. Reconstructing analogous centralization, history, context, verification, governance, and reversibility outside code is now the binding constraint on progress. Practically, this suggests that organizations seeking to deploy knowledge-work agents should prioritize building action logs, sandboxed verification, and layered access control before assuming model upgrades alone will close the reliability gap.

Sources

About the Author

Sean Weldon is an AI engineer and systems architect specializing in autonomous systems, agentic workflows, and applied machine learning. He builds production AI systems that automate complex business operations.

LinkedIn | Website | GitHub