Build and adopt production AI agent infrastructure in 2026. Covers framework selection (LangGraph, CrewAI, AutoGen, MCP), orchestration patterns, evaluation, observability, memory systems, and tool use. Also covers the SOCIAL dimension: how to sell agent infrastructure internally, change management, measuring ROI, building trust in autonomous systems, and scaling adoption across teams. Activate on: "agent infrastructure", "agent framework comparison", "which agent framework", "sell AI tools internally", "agent adoption", "agent observability", "agent evaluation", "MCP architecture", "agentic mesh", "enterprise AI agents", "AI change management", "agent ROI". NOT for: building specific agents (use ai-engineer), designing agent behavior patterns (use agentic-patterns), prompt tuning (use prompt-engineer).
Installer avec Codex ou Claude Copiez ce prompt, collez-le dans Codex, Claude ou un autre assistant, puis laissez-le vérifier la page du skill et l'installer pour vous.
Une commande directe contourne le prompt de vérification. Examinez la source avant de l'exécuter.
Build and adopt production AI agent infrastructure in 2026. Covers framework selection (LangGraph, CrewAI, AutoGen, MCP), orchestration patterns, evaluation, observability, memory systems, and tool use. Also covers the SOCIAL dimension: how to sell agent infrastructure internally, change management, measuring ROI, building trust in autonomous systems, and scaling adoption across teams. Activate on: "agent infrastructure", "agent framework comparison", "which agent framework", "sell AI tools internally", "agent adoption", "agent observability", "agent evaluation", "MCP architecture", "agentic mesh", "enterprise AI agents", "AI change management", "agent ROI". NOT for: building specific agents (use ai-engineer), designing agent behavior patterns (use agentic-patterns), prompt tuning (use prompt-engineer).
allowed-tools
Read,Write,Edit,Bash,Glob,Grep,WebSearch,WebFetch
metadata
{"category":"AI & Agents","tags":["agents","infrastructure","frameworks","adoption","observability","evaluation","change-management","enterprise"],"provenance":{"kind":"first-party","owners":["port-daddy"]},"pairs-with":[{"skill":"multi-agent-coordination","reason":"Coordination patterns sit on top of agent infrastructure"},{"skill":"agentic-patterns","reason":"Behavioral patterns inform infrastructure design choices"},{"skill":"agentic-app-architecture","reason":"App-shape decisions (transparency, memory, context economics) precede the infra plan this skill builds"},{"skill":"agent-work-receipt-designer","reason":"Once infra ships, receipts give the audit trail this skill's Production Readiness gate requires"}],"io-contract":{"kind":"deliverable","consumes":["[Truncated]","[Truncated]"],"produces":["[Truncated]","[Truncated]"]}}
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
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:
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
Alternative considered: CrewAI (rejected - single agent task, not team)
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
Pilot Scope: Start with one repo, non-critical reviews only
Human reviewers still required for approval
Agent provides "pre-review" suggestions
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
What Novice Misses: Would build complex multi-agent system, skip evaluation pipeline
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:
Migration Trigger: AutoGen conversations unpredictable, hard to debug, no state persistence
Framework Analysis:
Current: AutoGen's free-form conversation model
Target: LangGraph's explicit state machine
Trade-off: More setup complexity for better control
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
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
What Novice Misses: Would rewrite everything at once, no comparison metrics
What Expert Catches: Run systems in parallel, measure quality differences, gradual migration
Scenario: 5 engineering teams want agent infrastructure, no central coordination
Decision Process:
Problem: Each team building isolated solutions, duplicated effort, no learning transfer
Solution: Centralized AI Studio providing shared infrastructure
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
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
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
What Novice Misses: Would let teams build in isolation, reinvent wheels
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.
