The Framework Is the Product

Every quarter, a new model leapfrogs the last. GPT-4o. Claude 3.5 Sonnet. Gemini 2.0 Flash. The benchmarks shuffle. The Twitter discourse rages. And enterprises watching from the sidelines draw the wrong conclusion: that the model is the moat.

It is not. Not even close.

Anthropic's January 2026 release notes for the Cowork preview show something more important than any benchmark gain: persistent tool use, structured delegation, and agent-to-agent handoff patterns built into the API surface. OpenAI's Agents SDK ships tracing and evaluation primitives as first-class concerns, not afterthoughts. The labs are telling you where the value is. Not in the weights. In the wiring.

Models are commoditising on a quarterly cycle. The framework -- orchestration, tool access, state management, evaluation, governance -- compounds. That is where enterprise advantage lives. And most organisations are investing in exactly the wrong layer.

Diagnosis: The Copilot Trap

The majority of enterprises I see are stuck in what I call the copilot trap. They deployed GPT-4 behind a chat interface, called it an AI strategy, and moved on. The copilot answers questions. It summarises documents. It drafts emails. Useful. But fundamentally passive -- it waits for a human to ask, responds, and forgets.

The problem is not that copilots lack capability. It is that the enterprise never built the infrastructure for anything beyond prompt-and-respond. No persistent context across sessions. No access to live operational data. No ability to take actions in downstream systems. No trace of what the AI did or why.

When these organisations try to graduate from copilot to autonomous agent -- say, an agent that monitors supply chain disruptions and reroutes orders proactively -- they hit a wall. The model can reason about the problem. But it has no way to query the ERP in real time, no authority to modify a purchase order, no evaluation framework to catch when it makes a bad call, and no audit trail when the CFO asks what happened.

This gap is architectural, not intellectual. The model got smarter, but the surrounding system stayed dumb.

%%{init: {'theme': 'base', 'themeVariables': {'primaryColor': '#1a2540', 'primaryTextColor': '#ffffff', 'primaryBorderColor': '#ffffff', 'lineColor': '#ffffff', 'background': '#0a0f1e', 'mainBkg': '#1a2540', 'nodeBorder': '#ffffff', 'edgeLabelBackground': '#1a2540'}}}%%
graph LR
    subgraph COPILOT["Copilot Mode"]
        H1["Human asks"] --> M1["Model responds"] --> H2["Human acts"]
    end
    subgraph AGENT["Agent Mode"]
        T["Trigger event"] --> A["Agent reasons"] --> TOOL["Uses tools"] --> ACT["Takes action"] --> EVAL["Eval checks"] --> LOG["Trace logged"]
    end
    style COPILOT fill:#1a2540,stroke:#ffb347,color:#ffffff,stroke-width:2px
    style AGENT fill:#1a2540,stroke:#00d4ff,color:#ffffff,stroke-width:2px
    style H1 fill:#1a2540,stroke:#ffb347,color:#ffb347
    style M1 fill:#1a2540,stroke:#ffb347,color:#ffb347
    style H2 fill:#1a2540,stroke:#ffb347,color:#ffb347
    style T fill:#1a2540,stroke:#00d4ff,color:#00d4ff
    style A fill:#1a2540,stroke:#00d4ff,color:#00d4ff
    style TOOL fill:#1a2540,stroke:#00d4ff,color:#00d4ff
    style ACT fill:#1a2540,stroke:#00ff88,color:#00ff88
    style EVAL fill:#1a2540,stroke:#00ff88,color:#00ff88
    style LOG fill:#1a2540,stroke:#00ff88,color:#00ff88

The copilot requires three components. The agent requires six. The gap between three and six is where most enterprise agent projects die.

Reframe: Chord Changes, Not Solos

Here is the connection that reshaped how I think about agent frameworks.

Jazz musicians do not improvise from nothing. A bebop solo over "Giant Steps" follows chord changes -- a harmonic structure that constrains and enables simultaneously. John Coltrane's famous improvisation on that track works precisely because the chord progression is demanding. The structure forces creative decisions that a player noodling over open space would never make. Remove the chord changes and you get noodling. Keep them and you get genius that sounds free but is deeply structured.

Agent frameworks are chord changes for AI.

Without a framework, a model with tool access is noodling. It might call the right API. It might not. It might retry on failure. It might loop forever. It might produce a great result with no trace of how it got there. That is fine for a demo. It is catastrophic for a process that handles customer money or patient data.

The Model Context Protocol (MCP) is a good example of structure enabling freedom. MCP standardises how agents discover and access tools -- a universal interface between the reasoning layer and the capability layer. An agent using MCP does not need custom integration code for every data source. It discovers available tools through a protocol, understands their schemas, and uses them within defined boundaries. The structure eliminates a category of integration chaos while expanding what the agent can actually do.

OpenClaw takes this further at the runtime level. OpenClaw provides the orchestration runtime; tools like NemoClaw act as governed retrieval adapters ensuring agents access approved context. The improvisation is real. But the chord changes keep it productive.

Framework: Intelligence, Agency, Accountability

I think about the enterprise agent stack in three layers. Most investment goes to layer one. Most value comes from layers two and three.

%%{init: {'theme': 'base', 'themeVariables': {'primaryColor': '#1a2540', 'primaryTextColor': '#ffffff', 'primaryBorderColor': '#ffffff', 'lineColor': '#ffffff', 'background': '#0a0f1e', 'mainBkg': '#1a2540', 'nodeBorder': '#ffffff', 'edgeLabelBackground': '#1a2540'}}}%%
graph TB
    subgraph L3["Layer 3: ACCOUNTABILITY"]
        EVAL["Evaluations"] --- TRACE["Tracing & Audit"] --- POLICY["Policies & Guardrails"]
    end
    subgraph L2["Layer 2: AGENCY"]
        ORCH["Orchestration"] --- TOOLS["Tool Access (MCP)"] --- STATE["State & Memory"]
    end
    subgraph L1["Layer 1: INTELLIGENCE"]
        MODEL["Foundation Model (GPT-4o / Claude / Gemini)"]
    end
    L1 --> L2
    L2 --> L3
    style L1 fill:#1a2540,stroke:#ffb347,color:#ffb347,stroke-width:2px
    style L2 fill:#1a2540,stroke:#00d4ff,color:#00d4ff,stroke-width:2px
    style L3 fill:#1a2540,stroke:#00ff88,color:#00ff88,stroke-width:2px
    style MODEL fill:#1a2540,stroke:#ffb347,color:#ffffff
    style ORCH fill:#1a2540,stroke:#00d4ff,color:#ffffff
    style TOOLS fill:#1a2540,stroke:#00d4ff,color:#ffffff
    style STATE fill:#1a2540,stroke:#00d4ff,color:#ffffff
    style EVAL fill:#1a2540,stroke:#00ff88,color:#ffffff
    style TRACE fill:#1a2540,stroke:#00ff88,color:#ffffff
    style POLICY fill:#1a2540,stroke:#00ff88,color:#ffffff

Layer 1: Intelligence. The foundation model. Reasoning, language understanding, code generation. This is what the benchmarks measure and the press covers. It matters, obviously -- but it is also the layer where you have the least differentiation. You are renting intelligence from a lab. So is your competitor. Switching cost is dropping every quarter. I would not build a strategy on being better at picking models.

Layer 2: Agency. The orchestration framework, tool integrations, and state management that turn a passive model into an active participant. This includes MCP-based tool discovery, persistent memory across interactions, multi-agent delegation, and workflow routing. This layer determines what the agent can do. Anthropic's Cowork preview and OpenAI's Agents SDK are both investing heavily here -- they recognise the model alone is insufficient. Layer 2 is where the architecture decisions live, and architecture decisions compound because they shape every agent you deploy afterward.

Layer 3: Accountability. Evaluations, tracing, and governance policies. OpenAI's Agents SDK tracing captures every tool call, every LLM invocation, every handoff in a structured trace. This is not a nice-to-have for regulated industries. It is a prerequisite for any autonomous system that touches real business processes. Evaluations catch regression before production. Policies define decision boundaries -- what the agent can authorise, what requires human escalation, what is outright forbidden. Without layer 3, you have no way to know if the agent is working correctly until a customer complains.

The counterintuitive insight: most enterprises could get more value from investing in layers 2 and 3 with a mid-tier model than from deploying a frontier model with no framework.

Application: Lemonade's AI Jim -- Three Layers in Practice

Lemonade Insurance illustrates the three-layer stack in production, not as a pilot.

Their AI claims agent, AI Jim, started as a textbook copilot -- helping human adjusters process claims faster. The redesigned system operates across all three layers. At the intelligence layer, AI Jim handles natural language claim submissions and policy interpretation. At the agency layer, it has direct tool access to Lemonade's claims database, policy engine, and payment system -- it can pull a claim, check coverage rules, and trigger settlement autonomously. At the accountability layer, every decision is traced, claims above defined thresholds route to human adjusters, and continuous evaluation monitors for drift.

The results are public. AI Jim processes 55% of claims fully automated, with a record 2-second claim settlement. 96% of first notices of loss are handled by AI. The harder win is auditability -- Lemonade operates in a regulated insurance market and the trace infrastructure is what makes autonomous claims processing viable with regulators.

What makes this instructive is what Lemonade got right at layer 2 that most enterprises miss: tightly scoped tool access. AI Jim interacts with specific, well-defined systems through governed interfaces -- not broad database access. The agent's scope is architecturally bounded, not just documented. That constraint is what makes autonomy safe.

Implication: Build the Stage, Not the Performer

The model race is exciting but misleading. The next GPT or Claude release will not solve your orchestration gaps, your missing audit trail, or your fragmented tool integrations. Those are framework problems, and frameworks are built, not bought.

Enterprises that invest in agency and accountability now will be able to swap in better models quarterly and see immediate compound gains. Those still optimising prompts on a copilot will find themselves rebuilding from scratch when the business demands actual autonomy. The framework is the product. Start building it.

Sources

Daniel Piatkowski Data & Analytics veteran shaping AI-native enterprises elicify.ai