a very clean two-year progression from AI-assisted engineering at the repo level to enterprise-scale agentic capability.

What you’re describing is a very clean two-year progression from AI-assisted engineering at the repo level to enterprise-scale agentic capability.

It starts with the repository, because that is where the work becomes real. The first problem was not “How do we build agents?” It was much simpler and more practical: How do we help developers write better code, produce better engineering artifacts, and put better software into production?

 That meant improving prompts, intent, repo structure, standards, tests, validation, and the day-to-day use of AI inside engineering teams. In other words, the first stage was about making the individual developer and the individual repository better.

Once teams got better at that, the next problem became obvious: they were repeating the same good work across repositories. One team had a useful automation, another had something similar, another had nothing. So the next stage was to stop reinventing those capabilities locally and create a reusable automation layer: shared skills, plugins, agents, hooks, standards, templates, and marketplace-style distribution.

The goal shifted from “help this developer” to “make the best engineering practices available to every developer.”

Then comes the shared-services layer. Repositories eventually need capabilities that should not live inside every repo: Jira, Confluence, databases, APIs, enterprise knowledge, security services, metrics, policy engines, or other internal and external systems.

That is where MCP becomes important—not as the architecture itself, but as a governed connection layer between repo-local AI and shared enterprise capabilities. The repository remains the working boundary, while shared services provide controlled access to capabilities outside that boundary.

And now you are arriving at the fourth stage: agentic workflows. At this point the question is no longer, “Can we build an agent?” The more mature question is, “Where does agentic behavior actually earn its complexity?” 

Deterministic software should stay deterministic. Agents make sense where there is interpretation, judgment, changing context, exception handling, discovery, or multi-step coordination. They may call MCP services, coordinate other agents, or span repo and enterprise layers—but only within explicit boundaries, permissions, policies, evidence requirements, and human handoffs.

So I would summarize your journey like this:

1. Repo Intelligence

Make developers and repositories better. Better intent, better code, better tests, better validation, better production outcomes.

2. Automation at Scale

Take what works repeatedly and turn it into reusable skills, hooks, plugins, agents, templates, and automation packages that every team can use.

3. Shared Enterprise Capability

Let repositories securely reach beyond themselves through governed shared services and MCP—without duplicating enterprise integrations in every repo.

4. Agentic Workflows

Use agents selectively where judgment and variability justify them, connecting repo capabilities and shared services while maintaining governance, observability, permissions, evidence, and human control.

The architectural thread through all four stages is important: you did not start with enterprise agents and work backward. You started with real engineering pain and progressively abstracted what proved valuable. 

That is probably the strongest part of the story.

And there is a fifth stage beginning to emerge from all of this: intent-driven orchestration. The human expresses the goal, constraints, inputs, outputs, and success criteria; the engineering environment determines which repo automation, shared service, MCP capability, deterministic workflow, or agent is appropriate to fulfill it.

That is where your last two years appear to be converging:

Developer → Repository → Automation Layer → Shared Services → Agentic Workflows → Intent-Driven Enterprise Engineering

The consistent principle underneath it all is: human owns the intent and boundaries; the platform increasingly owns the execution.