"The best minds of my generation are thinking about how to make agents work together."
Gino Ferrand, writing today from Denver 🏔️
Over the past few weeks, a flood of releases has signaled something deeper than feature creep:
We’re shifting from AI-enhanced code to AI-native systems.
Tools like Microsoft’s Semantic Kernel and Azure AutoGen SDK, both spotlighted at Build 2025, are making agent-based orchestration real. Engineers aren’t just prompting anymore...they’re designing workflows where AI agents call tools, run functions, break down tasks, and coordinate with other agents. It’s a different way of building software.
Instead of imperative code that scripts every step, developers are writing agentic systems that behave more like adaptive workers: reacting to data, fetching docs, modifying databases, and iterating in loops. This isn’t science fiction. It’s shipping now.
The rise of frameworks, protocols, and extensions
Semantic Kernel’s recent unification with Azure’s Agent Service is a huge leap: teams can now go from prototype to production using one stack. Microsoft even teased agent observability tools...like thought tracing and cost metrics...as part of their AI Foundry push. The goal? Bring the same rigor we have in microservices to AI agents.
Meanwhile, LangChain keeps evolving on the open-source side, and new frameworks like Dust are bubbling up, helping internal dev tools become LLM-native. On Hacker News, one commenter described Dust as the first tool that made building LLM flows feel composable and transparent.
Even IDEs are adapting: JetBrains’ AI Assistant and GitHub’s soon-to-launch Copilot Skills (allowing third-party “skills” in Copilot chat) point to a near-future where developers can shape AI into custom teammates—say, a bot that pulls in Stripe docs or queries production metrics on demand.
This all points to a profound shift: AI isn’t just an add-on anymore. It’s a layer of the architecture.
AI-Enabled Nearshore Engineers: The Ultimate Competitive Edge
The future of software engineering isn’t just AI... it’s AI-powered teams. By combining AI-driven productivity with top-tier remote nearshore engineers, companies unlock exponential efficiency at a 40-60% lower cost, all while collaborating in the same time zone.
✅ AI supercharges senior engineers—faster development, fewer hires needed
✅ Nearshore talent = same time zones—real-time collaboration, no delays
✅ Elite engineering at significant savings—scale smarter, faster, better
Architecting for agents
Engineering leaders are taking note. Forward-thinking teams are asking:
How do we structure docs so agents can parse them?
Can we build APIs that are agent-readable?
How do we debug an AI agent’s reasoning?
Some are even rethinking internal tooling so that AI systems... just humans...can navigate and contribute. This demands new observability layers, new security guardrails, and new mental models for testing workflows where humans and AIs act in tandem.
Microsoft’s push for agent telemetry...tracing logic steps, analyzing performance, monitoring latency...suggests that the infrastructure for all this is catching up fast. It’s not enough to build the agent. You have to monitor it, refine it, and prove it’s doing what you expect.
The bottom line
It’s early days, but the trajectory is clear:
The next wave of AI in software isn’t about better autocomplete.
It’s about AI that acts.
And for engineering leaders, that means building systems where AI isn’t just a tool… it’s a collaborator.
– Gino Ferrand, Founder @ TECLA