Amazon's AgentCore creates orchestration lock-in, not agent portability

Amazon just announced AgentCore — their orchestration layer for multi-agent systems. The pitch is simple: instead of building agent coordination from scratch, you get pre-built patterns for routing, handoffs, and shared state.

Here's what they're not telling you: orchestration platforms create a new kind of vendor lock-in. Not the old "migrate your data" lock-in — the "rebuild your entire agent architecture" lock-in.

I've seen this movie before. When everyone was building on Zapier, teams optimized for Zapier's trigger-action model. When they hit limits, they couldn't just switch tools — they had to rethink their entire automation strategy.

Agent orchestration is heading the same direction. Platforms like AgentCore, LangGraph, and AutoGen each have their own coordination primitives:

• AgentCore: Message queues and state machines
• LangGraph: Graph nodes and conditional edges
• AutoGen: Conversational handoffs and group chat

Pick one, and you're building in their language. Your agent team becomes a collection of platform-specific configs instead of portable logic.

The alternative? Build coordination at the protocol level, not the platform level.

Here's what that looks like in practice:

# Agent handoff via shared workspace
echo "TASK: Review PR #123" > /shared/queue/code-review.task
echo "FROM: triage-agent" >> /shared/queue/code-review.task
echo "CONTEXT: Security concern flagged" >> /shared/queue/code-review.task

Your agents coordinate through files, not APIs. Each agent watches for relevant task files, processes them, and writes results back. No orchestrator. No message queues. No vendor APIs.

This isn't just about avoiding lock-in — it's about building systems that actually work when things break. Platform orchestrators fail in spectacular ways. A network hiccup kills your entire agent team. A rate limit cascades through every handoff.

File-based coordination degrades gracefully. One agent goes down? The others keep working. The orchestrator crashes? Agents pick up where they left off by reading the shared state.

Warning: This only works if your agents run in the same environment. Cloud agents coordinating through Dropbox will be slow and unreliable.

The real insight here: orchestration is becoming a commodity, but agent personas aren't. Amazon can build better message queues than you. They can't build better domain expertise than you.

Spend your time building agents that understand your business, not learning another coordination framework. The orchestration layer will be solved by infrastructure companies. The agent layer — the part that actually creates value — that's where you want to be building.

Your competitive advantage isn't how your agents talk to each other. It's what they know about your customers, your processes, your edge cases. Build that knowledge into portable agents, and let the platform wars play out around you.