Vendor Lock-In and the Hidden Ethics of Agent Frameworks

The question that brought you here asks about the ethical risks of “closed” agent frameworks. The framing is wrong, and the wrongness is exactly where the conversation needs to start. OpenAI Agents SDK is open source. Google ADK is open source. Microsoft’s Agent Framework 1.0, released this April, is open source. The lock-in worth arguing about is not licensing — it is something quieter, more architectural, and far harder to walk away from.

What “Open” Has Stopped Telling Us

For most of the cloud era, “open source” was a reasonable proxy for “I can leave.” If the source compiles, the data exports, and the protocols are public, the exit ramp exists. That heuristic worked well enough that a generation of architects came to treat the license file as the final ethical question.

It is not the final question anymore. An Agent Frameworks Comparison in 2026 is not a library you import. It is a moving system: an orchestrator, a memory layer, a planning loop, a tool harness, an observability pipeline, and a deployment path — each of those layers carrying its own assumptions about who runs the workload, who sees the traces, and who keeps the keys to the data. License covers exactly one of those layers. The interesting choices live in the others.

That gap is where the real ethical conversation begins.

The Honest Case for Picking the Big Names

Before naming what is uncomfortable, it is worth saying what is true. The frameworks coming out of OpenAI, Google, Microsoft, and the LangChain ecosystem are genuinely good. They solve hard problems that, three years ago, every team had to solve from scratch: state management for Multi Agent Systems, retry policy, tool routing, structured output, sandboxing, the awkward seams between Agent Planning And Reasoning and execution. They ship with documentation, semantic versioning, security response, and the kind of investment that only a vendor with a stake in the outcome can sustain.

There is also a practical argument. A small team building a customer support agent does not have the luxury of writing its own orchestrator. Picking a framework that the model provider already optimizes against — gpt-realtime-1.5 inside the OpenAI Agents SDK, Gemini inside Google ADK — collapses weeks of integration work into an afternoon. The harness, the sandbox primitives, and the Codex-style filesystem tools move in lockstep with the hosted services they were designed to call. That tight coupling is, on launch day, a feature.

The case is real. So is the bill that arrives later.

Where the Lock-In Actually Lives

Strip away the license argument and the picture sharpens. The lock-in is not in the code you can fork. It lives in four places the license never reaches.

The first is the harness. OpenAI’s April 2026 update — described in OpenAI Blog — added sandbox execution, Codex-style filesystem tools, and gpt-realtime-1.5 hooks that are specified in open code but designed around OpenAI-hosted services. You can read the source. You cannot easily rebuild the surrounding sandbox.

The second is memory. Agent Memory Systems are the part of an agent stack that quietly accumulates the most strategic value: every preference, every prior session, every retrieved fact about every user. LangChain has publicly warned that proprietary agent memory could create vendor monopolies, because short and long-term memory flows through the harness — and if the harness is behind a proprietary API, the data effectively stays where it lands, per Blockchain.News.

The third is the deployment path. Google ADK is officially model-agnostic per Google’s ADK GitHub repository, and that matters — but the best-supported, lowest-friction deployment path runs through Vertex AI and Gemini Enterprise, as described in Google Developers Blog. Open licensing on the framework. Soft gravity at the runtime.

The fourth is the question of who controls the upgrade pace. Microsoft moved AutoGen into maintenance mode in early 2026, replacing it with the new Agent Framework 1.0, per VentureBeat. The framework is still open. The roadmap is not yours.

Industry analysis suggests a substantial majority of surveyed enterprises now flag proprietary dependencies in agent memory, model integration, and orchestration as a serious adoption concern, per Kai Waehner’s analysis. The figure is directional — the survey is vendor-adjacent — but the pattern matches what teams describe in private.

The license is open. The exit, in practice, is expensive.

A History Lesson the Industry Keeps Forgetting

We have been here before, and it is worth saying so plainly. Java EE was open. Containers were open. Kubernetes is open. None of that prevented the long arc by which generic workloads slowly fused with the cloud they ran on, until “lift and shift” became a multi-year board-level program. The lock-in did not arrive through licensing. It arrived through the operational surface — the queues, the IAM model, the observability stack, the managed services that turned out to be load-bearing.

Agent frameworks are repeating that pattern with the speed compressed into months. The orchestrator is becoming the new operating system: the layer that decides which model is called, which tool is allowed, which memory is consulted, which trace is recorded, which policy is enforced. An orchestrator is a governance surface, not a library. Treating that surface as if it were a logging utility — chosen on convenience, replaced on a whim — is a category error we keep making at scale.

The history is not deterministic. It is, however, instructive. The teams that came out of the cloud era least encumbered were the ones who picked their primitives with the assumption that the vendor would, eventually, want to make leaving expensive.

The Argument

Thesis: The ethical risk of building on a major agent framework in 2026 is not that it is closed, but that we have stopped asking what “open” should mean once orchestration becomes the layer where consequential decisions are made.

This conclusion is uncomfortable because it cannot be solved by reading more license files. It demands a different question: not “is the source available?” but “if my framework vendor doubled its prices, deprecated my memory format, and tied its best features to its hosted runtime, how long would it take me to leave, and what would I lose on the way out?” That is an architectural question. It is also a moral one, because the answer determines who actually controls the behavior of systems that increasingly act on behalf of users who never read the system prompt.

A framework can be perfectly open and still leave its users with no real exit. That is the soft lock-in worth naming, and it is the conversation the “open vs closed” framing keeps suppressing.

The Questions Architects Owe Themselves

The constructive move is not to abandon the major frameworks. It is to interrogate the dependency before signing it.

What part of the agent’s memory leaves with us if we go? Where does the trace data live, and who can read it? Which features only work on the vendor’s hosted runtime, and which would survive a self-hosted deployment? If we move from one orchestrator to another in eighteen months, what is the order of magnitude of the migration, and is anyone in the team allowed to estimate it honestly?

Those questions are not technical. They are governance questions wearing technical clothes. A team that cannot answer them is not making an architectural choice — it is delegating one.

Where This Argument Is Weakest

Honesty requires naming the counter-evidence. The Model Context Protocol was donated by Anthropic to the Linux Foundation’s Agentic AI Foundation in December 2025, with widespread adoption across Claude, ChatGPT, Cursor, Copilot, Gemini, and VS Code, per the Linux Foundation press release. That is real interoperability work, and it weakens the lock-in story for tool-level integration.

OpenTelemetry’s agent observability effort — common semantic conventions for CrewAI, AutoGen, LangGraph, and others, per the OpenTelemetry Blog — is moving in the same direction at the trace layer. If these standards harden, exit costs fall. The argument I am making depends on the assumption that gravity in the harness, the memory, and the deployment path will outpace standardization. That assumption could turn out to be wrong, and I would welcome being wrong about it.

The Question That Remains

The licenses are open. The roadmaps are not. Somewhere between those two facts is the real ethical surface of the agent stack — the place where decisions about whose memory, whose trace, and whose runtime accumulates the most consequence quietly get made. The question worth carrying out of this essay is simple: when our agents finally act with real autonomy on behalf of real people, who will hold the keys to the layer where that autonomy is configured — and was anyone in the room when that was decided?