Agents All the Way Down

Here's a number that should make every engineering leader pause: according to JetBrains' AI Pulse survey (January 2026), 90% of professional developers now use AI tools regularly at work. Claude Code adoption jumped 6x in under a year to 18% work adoption. The shift is unmistakable.

But the real disruption isn't which tool developers use. It's that the SDLC as we've known it for decades is fundamentally breaking down. When agents can generate, validate, and deploy in parallel, the sequential pipeline ceases to make sense.

"ADLC is not SDLC with AI tools added. It is a different operating model - redesigned for a world where the primary execution unit is an agent, not a human."

- adlc.io

Arthur.ai's take on ADLC adds the reliability dimension: the core of the lifecycle is an "Agent Development Flywheel" where live usage reveals failure modes, which grow eval suites, which ship improvements with regression-aware metrics.

If ADLC is the operating model, multi-agent architectures are the execution engine. Four dominant patterns have emerged:

This is already happening in production. AgentOrchestra demonstrates hierarchical "conductors" with MCP-oriented tool management. LangGraph Supervisor provides a library specifically for this. CrewAI achieves it with Process.hierarchical.

In human organizations, promotion and demotion are formal HR processes. In multi-agent systems, they're dynamic routing decisions - probabilistic, continuous, and automated. Every delegation is a hiring decision. Every evaluation is a performance review. In milliseconds.

class AgentRouter:
    def __init__(self, candidates: list[Agent]):
        # Initialize beliefs with uniform priors
        self.beliefs = {a.id: BetaDistribution(1, 1) for a in candidates}
        self.failure_counts = defaultdict(int)

    def delegate(self, task: Task) -> Agent:
        # Thompson sampling: promote high-performers probabilistically
        scores = {
            agent_id: belief.sample()
            for agent_id, belief in self.beliefs.items()
        }
        return max(scores, key=scores.get)

    def on_result(self, agent_id: str, judge_verdict: Verdict):
        # Update beliefs based on judge evaluation
        if judge_verdict.passed:
            self.beliefs[agent_id].record_success()
            self.failure_counts[agent_id] = 0
        else:
            self.beliefs[agent_id].record_failure()
            self.failure_counts[agent_id] += 1

        # Demotion: repeated failures trigger model downgrade
        if self.failure_counts[agent_id] >= 3:
            self.demote(agent_id)

    def demote(self, agent_id: str):
        # Options: switch model, lower temperature, require evidence
        agent = self.agents[agent_id]
        agent.model = agent.fallback_model
        agent.require_citations = True
        self.beliefs[agent_id] = BetaDistribution(1, 5)  # pessimistic prior

Two protocols have emerged as dominant - but they solve different problems at different layers.

MCP is the USB standard for AI tools. A2A enables cross-org agent collaboration via Agent Cards at /.well-known/agent.json. Teams use both: MCP within a stack, A2A across trust boundaries.

Models have parameters. Agents have tools. But what makes an agent actually good at a specific task? Skills - versionable packages of procedural expertise centered on SKILL.md. Anthropic's engineering team and the Agent Skills spec formalize four layers:

The convergence: skills teach workflow; MCP/APIs supply interfaces. Skills are becoming dependencies, managed with the same rigor as npm packages.

"The new paradigm is characterized by developers who are simultaneously users, creators, and governors of intelligent systems."

- IDC FutureScape - 70% of developers will partner with autonomous agents by 2030

Theory is useful. Shipping is better. Five steps to your first hierarchical multi-agent system:

{
  "task": "implement_feature",
  "input": { "spec": "...", "context_files": ["..."] },
  "output": { "files_changed": ["..."], "tests_added": 3 },
  "constraints": { "max_tokens": 50000, "timeout_ms": 120000 }
}

from langgraph.graph import StateGraph, END
from langgraph.prebuilt import create_react_agent
from typing import TypedDict, Literal

class AgentState(TypedDict):
    task: str
    plan: str
    code: str
    review: str
    status: Literal["planning", "coding", "reviewing", "done"]

def supervisor(state: AgentState) -> dict:
    """Route to the next agent based on current state."""
    if not state.get("plan"):
        return {"status": "planning"}
    if not state.get("code"):
        return {"status": "coding"}
    if not state.get("review"):
        return {"status": "reviewing"}
    return {"status": "done"}

def route(state: AgentState) -> str:
    return state["status"]

# Build the graph
graph = StateGraph(AgentState)
graph.add_node("supervisor", supervisor)
graph.add_node("planner", planner_agent)
graph.add_node("coder", coder_agent)
graph.add_node("reviewer", reviewer_agent)

graph.set_entry_point("supervisor")
graph.add_conditional_edges("supervisor", route, {
    "planning": "planner",
    "coding": "coder",
    "reviewing": "reviewer",
    "done": END,
})

# Each worker returns to supervisor for next routing decision
for node in ["planner", "coder", "reviewer"]:
    graph.add_edge(node, "supervisor")

app = graph.compile()