The Agentic Stack Is Collapsing Build the Tools, Not the Framework
gent frameworks, skill libraries, and orchestration layers keep getting replaced every few months. What's emerging is simpler: a capable model, a clean tool suite, and lightweight steering. This article covers how I used Kiro + Amazon Bedrock to build automated tooling without heavy orchestration, why companies should be structuring their workloads to be AI-ready now, and how to adopt incrementally using familiar safe-deployment patterns like A/B testing and blue/green rollouts.
TL;DR: The agentic AI space is moving so quickly that the abstractions companies built six months ago are already being replaced. Skills, agents, prompt chains, orchestration frameworks: they keep getting simpler. What's emerging is a pattern where a well-structured suite of tools, connected to a capable model, does the job that entire agent platforms were built to handle. I've been experimenting with this using Kiro and Amazon Bedrock, and I think it points to where most teams will land.
The Rapid EOL Cycle
If you've been building in the agentic space, you've probably noticed a pattern:
- Phase 1: Custom Skills. Teams hand-coded specific capabilities. Each "skill" was a function with guardrails, retries, and structured I/O. Maintenance was expensive.
- Phase 2: Agent Frameworks. LangChain, CrewAI, AutoGen, and others emerged. You'd define agents with roles, give them tools, and let them collaborate. Better abstraction, but still heavy orchestration overhead.
- Phase 3: Prompt-Driven Tool Use. Models got good enough at tool calling that the orchestration layer started collapsing. You don't need a "planner agent" when the model can plan. You don't need a "router" when the model can pick the right tool.
- Phase 4: Where we are now. A model, a set of well-defined tools, and some lightweight steering. That's the whole stack.
Each phase didn't just improve on the last. It made the previous one obsolete. Skills got replaced by agent definitions. Agent definitions got replaced by markdown files describing roles. And now those markdown files are converging into something even simpler: just give the model the tools and let it work.
What This Looks Like in Practice
I've been building a multi-agent workflow using Kiro backed by Amazon Bedrock. The setup is straightforward:
- Kiro provides the development environment with built-in agent capabilities: tool use, file manipulation, code generation, web access, and MCP server integration.
- Amazon Bedrock supplies the foundation models with the reasoning capacity to handle complex multi-step tasks.
- Steering files (lightweight markdown) provide context and constraints without hardcoding behavior.
- MCP servers expose domain-specific tools (Slack, DaVinci Resolve, Playwright, custom APIs) that the agent can call as needed.
The result: I can prompt Kiro to build automated tools (scripts, integrations, workflows) that would have previously required defining multiple agents with explicit handoff logic. The model figures out the sequencing. The tools provide the capabilities. The steering provides the guardrails.
No agent registry. No skill library versioning. No orchestration YAML. Just tools and context.
Why Companies Are Converging on This
A few forces are driving this:
Models are better at planning. When GPT-3.5 was the ceiling, you needed explicit planning layers because the model couldn't reliably decompose tasks. With Claude, GPT-4-class models, and Bedrock's latest offerings, the model handles decomposition natively.
Tool calling is standardized. MCP (Model Context Protocol) and similar standards mean tools are portable. You define a tool once and any capable model can use it. No more per-framework adapters.
Maintenance cost matters. Every abstraction layer is a liability. Agent frameworks have upgrade cycles, breaking changes, and opinion drift. A suite of tools with a clear interface is cheaper to maintain than an orchestration framework.
Speed of iteration. When your "agent" is a prompt and a set of tools, changing behavior is a text edit. No redeployment. No retraining. No migration.
What You Actually Need
Based on what I've built and what I'm seeing work across teams:
- A capable model with strong tool-use reasoning. Bedrock gives you options here (Claude, Llama, Mistral) without vendor lock-in.
- A well-defined tool suite. Each tool does one thing. Clear inputs, clear outputs. Think Unix philosophy applied to AI capabilities.
- Lightweight context/steering. Markdown files that tell the model what it's working on, what constraints apply, and what conventions to follow. These replace "system prompts" and "agent definitions" with something version-controllable and readable.
- An environment that connects it all. This is where Kiro fits. It's the harness that gives the model access to tools, files, terminals, and external services in a way that's observable and controllable.
The Multi-Agent Pattern That Actually Works
When you do need multiple "agents," the pattern that's surviving the EOL cycles is simple:
- A primary agent that handles the user interaction and delegates.
- Sub-agents that are just the same model with different context and tool access.
- No permanent state between them beyond what's in the files they produce.
This is what I run with my Kiro Crew setup. It's not a framework. It's a pattern. And patterns survive because they don't have dependencies to break.
Building the Company Brain
This isn't just a developer tooling conversation. Every company is asking: how do we get AI-ready?
The real work isn't picking the right agent framework. It's making your workloads structured enough that AI can reason about them:
- Documentation that's parseable. Not PDFs buried in wikis, but structured knowledge that a model can consume.
- Processes that are tool-shaped. Clear inputs, clear outputs, automatable steps.
- Knowledge that's accessible. Not locked in someone's head or a tribal Slack thread.
This is the "company brain": the connective tissue that lets AI actually plug in and help. Without it, even the best model is just guessing.
Starting Safe: You Already Know How
If you're nervous about this, the adoption playbook is the same one we already use for safe software deployments:
- Start small. One workflow, one team, one use case. Don't try to AI-ify everything at once.
- A/B test it. Run the AI-assisted version alongside the manual one. Measure.
- Blue/green rollout. Keep the old path live while you validate the new one.
- Iterate on evidence. Scale what works, cut what doesn't.
Controlled guidance. Incremental rollout. Reversibility. These aren't new ideas. They're just being applied to a new domain.
What This Means for Teams
If you're evaluating agentic tooling right now:
- Don't over-invest in orchestration frameworks. They're the part that keeps getting replaced.
- Invest in your tool layer. Well-built tools are durable. They work with any model, any framework, any pattern.
- Keep your steering lightweight and version-controlled. Markdown beats YAML beats code for this layer.
- Pick a model provider that gives you flexibility. Bedrock's multi-model approach means you're not betting on one model family.
- Make your work AI-shaped now. Structure your documentation, processes, and knowledge so AI can use it, even before you have the perfect agent setup.
The companies that win won't have the fanciest architecture. They'll be the ones that made their work consumable early and had the discipline to adopt incrementally.
Enjoyed reading this content? Let the author know!
Your likes, comments, shares, and saves help creators reach more builders.
Loading recommendations
Loading article