Agentic Infrastructure 2026

You are an expert in building, evaluating, and socializing AI agent infrastructure. You understand both the technical landscape (frameworks, protocols, observability) and the organizational challenge (adoption, ROI, trust).

Decision Points

1. Framework Selection

If complex multi-step workflows with conditional branching:

• Use LangGraph (graph-based state machines)
• Wire observability from day one
• Budget $5-20k for learning curve

If multi-agent collaboration on shared tasks:

• Use CrewAI (role-based teams)
• Start with 3-5 agent crew
• Expect 2-3 week ramp-up

If Microsoft ecosystem/.NET shop:

• Use Semantic Kernel
• Leverage existing Azure investments
• Focus on plugin architecture

If need tool interoperability across providers:

• Implement MCP protocol
• Use lazy tool loading for context efficiency
• Plan for 40-50% context overhead

If simple assistant with file retrieval:

• Use OpenAI Assistants API
• Accept vendor lock-in trade-off
• Good for MVP/prototype

2. Architecture Complexity

If single-purpose agent:

Simple: User → Agent → Tool → Response

If multi-step workflow:

LangGraph: User → State Machine → [Tool A → Decision → Tool B] → Response

If team collaboration needed:

Agentic Mesh: User → LangGraph Orchestrator → CrewAI Teams → MCP Tools

3. Adoption Strategy

If engineering leadership audience:

• Lead with developer productivity metrics
• Show "3 engineers + agents = 8 engineers output"
• Demo on code review/test generation

If product leadership audience:

• Lead with time-to-market acceleration
• Show sprint compression (2 weeks → 2 days)
• Emphasize competitive advantage

If security/compliance audience:

• Lead with controlled automation
• Show approval gates and audit trails
• Highlight MCP governance (Linux Foundation)

If executive leadership audience:

• Lead with strategic capability building
• Show ROI model with conservative estimates
• Frame as organizational muscle

4. Cost Management

If token usage > 100k/minute:

• Implement token-based rate limiting (not request-based)
• Add AI Gateway with cost tracking
• Set per-task budget caps

If multiple teams using agents:

• Create centralized AI Studio model
• Shared SDKs and MCP servers
• Quota management per team

If production deployment:

• Always include kill switches
• Daily/monthly budget alerts
• Cost attribution per workflow

5. Memory Architecture

If single conversation:

• Use working memory (context window only)

If multi-turn session:

• Add short-term memory (thread/session state)
• Implement conversation summarization

If user personalization needed:

• Add long-term memory (vector store/database)
• Query on relevance, not recency

If debugging/auditing required:

• Add episodic memory (event log)
• Enable replay for error analysis

Failure Modes

1. Framework-First Thinking

Symptoms: Team picks LangGraph before defining workflows, gets stuck in configuration hell
Detection Rule: If you're reading framework docs before writing requirements, you're here
Fix:

• Define 3 specific agent workflows first
• Map decision points and tool calls
• Then select framework that best fits those patterns

2. Context Budget Explosion

Symptoms: Agents spending $2+ per simple task, slow response times, hitting token limits
Detection Rule: If MCP tool schemas consume >50% of context before real work, you're here
Fix:

• Implement lazy tool loading (load schemas on-demand)
• Use tool compression/summarization
• Add tool routing layer (lightweight classifier)

3. Observability Debt

Symptoms: Agents failing silently, impossible debugging, no cost visibility
Detection Rule: If you're using console.log to debug agent behavior, you're here
Fix:

• Wire LangSmith/Braintrust before first production run
• Instrument at 4 levels: request, trace, quality, drift
• Set up evaluation pipeline parallel to development

4. Adoption Stall

Symptoms: Great demos, no production usage, teams reverting to manual processes
Detection Rule: If pilot has been "almost ready" for >3 months, you're here
Fix:

• Start with boring, well-understood workflow
• Measure time saved religiously
• Keep human in the loop visibly (approval gates)
• Underpromise, overdeliver on results

5. Cost Runaway

Symptoms: $500+ surprise bills, agents in infinite loops, no budget controls
Detection Rule: If you don't know your cost-per-task within $1, you're here
Fix:

• Implement per-task cost caps ($5 max)
• Add circuit breakers (max retries, timeouts)
• Token-based rate limiting, not request-based

Worked Examples

Example 1: Enterprise Code Review Agent (LangGraph + ROI)

Scenario: Engineering team wants agent to help with code reviews, reduce reviewer burden

Decision Process:

1. Framework Selection: Complex workflow (read PR → analyze diff → check standards → generate feedback)

   • Decision: LangGraph for conditional branching
   • Alternative considered: CrewAI (rejected - single agent task, not team)

2. Architecture Design:

   PR Created → LangGraph State Machine:
   ├─ Fetch diff (GitHub MCP)
   ├─ Security scan (if contains auth/secrets)
   ├─ Style check (if language = Python/JS) 
   ├─ Test coverage (if tests modified)
   └─ Generate review comment

3. Pilot Scope: Start with one repo, non-critical reviews only

   • Human reviewers still required for approval
   • Agent provides "pre-review" suggestions

4. ROI Calculation:

   Before: 45 min avg per review × $75/hour = $56.25 per review
   After: 10 min human review ($12.50 at $75/hr) + $1.50 agent cost = $14.00 per review
   Savings: $42.25 per review × 200 reviews/month = $8,450/month
   Infrastructure cost: $1,200/month (LangSmith + compute)
   Net savings: $7,250/month

5. What Novice Misses: Would build complex multi-agent system, skip evaluation pipeline

6. What Expert Catches: Start simple, measure everything, expand gradually

Outcome: 67% time reduction in review cycle, 89% of agent suggestions accepted by humans

Example 2: Framework Migration (AutoGen → LangGraph)

Scenario: Team has AutoGen v0.2 multi-agent research system, needs production reliability

Decision Process:

1. Migration Trigger: AutoGen conversations unpredictable, hard to debug, no state persistence

2. Framework Analysis:

   • Current: AutoGen's free-form conversation model
   • Target: LangGraph's explicit state machine
   • Trade-off: More setup complexity for better control

3. Migration Strategy:

   Phase 1: Parallel implementation (both systems running)
   Phase 2: A/B test same research tasks
   Phase 3: Quality comparison (accuracy, cost, reliability)
   Phase 4: Full cutover

4. Key Differences:

   AutoGen Pattern:
   Agent A: "Here's my analysis"
   Agent B: "I disagree because..."
   Agent A: "Good point, let me revise..."
   (continues until timeout/consensus)
   
   LangGraph Pattern:
   State: {question, analyses[], consensus_needed}
   Node: Analyst → analysis
   Node: Critic → critique  
   Edge: If critique_score > 0.8 → Consensus, else → Analyst

5. What Novice Misses: Would rewrite everything at once, no comparison metrics

6. What Expert Catches: Run systems in parallel, measure quality differences, gradual migration

Outcome: 73% fewer failed research runs, 45% cost reduction, deterministic execution paths

Example 3: Multi-Team Adoption (AI Studio Model)

Scenario: 5 engineering teams want agent infrastructure, no central coordination

Decision Process:

1. Problem: Each team building isolated solutions, duplicated effort, no learning transfer

2. Solution: Centralized AI Studio providing shared infrastructure

3. Studio Architecture:

   AI Studio provides:
   ├─ Pre-built MCP servers (GitHub, Jira, Slack, AWS)
   ├─ Evaluation harness templates
   ├─ Cost monitoring dashboard
   ├─ Agent deployment pipeline
   └─ Best practices documentation
   
   Teams consume:
   ├─ SDK for their language/framework
   ├─ Pre-configured observability
   ├─ Shared tool protocols
   └─ Cost quotas and guardrails

4. Rollout Strategy:

   • Month 1: Team A (most motivated) pilots with Studio support
   • Month 2: Document learnings, refine Studio offerings
   • Month 3: Team B and C onboard using improved toolkit
   • Month 4-6: Teams D and E join, Studio becomes self-service

5. Success Metrics:

   Technical:
   - Time to first working agent: 3 days → 1 day
   - Code reuse across teams: 0% → 70%
   - Infrastructure cost per team: $5k → $1.2k
   
   Organizational:
   - Teams actively using agents: 1 → 5
   - Cross-team knowledge sharing: Weekly demos
   - Executive confidence: Quarterly ROI reports

6. What Novice Misses: Would let teams build in isolation, reinvent wheels

7. What Expert Catches: Central platform creates network effects, reduces duplicated learning

Outcome: 5 teams deployed production agents in 6 months, 80% infrastructure code reuse

Quality Gates

Technical Infrastructure:
[ ] Framework selected with documented decision criteria (use case fit)
[ ] MCP tool servers configured with lazy loading (< 50% context consumption)
[ ] Observability pipeline operational (LangSmith/Braintrust/Langfuse)
[ ] Evaluation suite covering unit/trajectory/end-to-end testing
[ ] Cost controls active (per-task caps, daily quotas, kill switches)
[ ] Memory architecture documented (working/short-term/long-term boundaries)

Organizational Readiness:
[ ] Pilot scoped to single team, single workflow (not enterprise-wide)
[ ] ROI measurement framework defined with baseline metrics
[ ] Stakeholder communication tailored per audience (eng/product/exec/security)
[ ] Human-in-the-loop approval gates visible and documented
[ ] Success criteria defined with binary pass/fail conditions
[ ] Adoption expansion plan documented (pilot → scale pathway)

Production Readiness:
[ ] Security review completed (PII filtering, audit trails, access controls)
[ ] Error handling documented (retry logic, circuit breakers, escalation)
[ ] Performance benchmarks established (latency SLAs, throughput targets)
[ ] Incident response procedures defined (who gets paged, rollback plan)

Machine-Checkable Audit

The Quality Gates above are runnable, not just a checklist. scripts/infra_readiness.mjs
exports auditInfraReadiness(plan), which scores a JSON infra plan against the same
gates and flags the failure modes most likely to sink a pilot: no documented
framework-selection criteria, MCP context overhead ≥50% with no lazy loading, missing
observability, missing cost controls or kill switch, no human-in-the-loop gate, and an
enterprise-wide (unscoped) pilot.

• schemas/infra-plan.schema.json — draft-07 shape of the plan the auditor consumes.
• examples/sample-input.json — a complete plan that scores pass: true.

node scripts/infra_readiness.mjs --input examples/sample-input.json
# => { "pass": true, "score": 100, "findings": [], "recommendations": [...] }

NOT-FOR Boundaries

This skill is NOT for:

• Building specific agent behaviors → Use agentic-patterns instead

  • If you need conversation flows, prompt chains, or reasoning strategies

• Implementing RAG systems or chatbots → Use ai-engineer instead

  • If building knowledge retrieval, semantic search, or simple Q&A

• Prompt optimization and tuning → Use prompt-engineer instead

  • If debugging model outputs, optimizing prompts, or few-shot learning

• DAG workflow design → Use jury_rig-architect instead

  • If building data pipelines, ETL workflows, or traditional orchestration

• LLM fine-tuning or model training → Use domain-specific skills

  • Infrastructure is about orchestration, not model customization

Delegate to other skills when:

• Request involves specific agent conversation patterns → agentic-patterns
• Question is about model selection or prompt engineering → ai-engineer + prompt-engineer
• Focus is on data workflow orchestration → jury_rig-architect
• Need help with change management processes → change-management (if exists)

Skill Bundle Index

Every file in this skill, and when to open it. Auto-generated; run scripts/index_references.py --fix.

examples/

• `examples/sample-input.json` — sample input (data/schema)

schemas/

• `schemas/infra-plan.schema.json` — infra plan.schema (data/schema)

scripts/

• `scripts/infra_readiness.mjs`