LangChain Ships CLI & Skills, Vercel Adds MCP Support

LangChain - CLI & Skills Packages for AI Coding Agents#

Source: https://blog.langchain.com/langsmith-cli-skills/ and https://blog.langchain.com/langchain-skills/ Credibility: High (first-party product launch with technical implementation details)

What happened: LangChain launched two skills packages that give AI coding agents built-in expertise in the LangChain ecosystem: LangSmith Skills (tracing, evaluation, testing) and LangChain Skills (building agents with LangChain, LangGraph, and related frameworks). Both packages ship with a CLI that agents can invoke directly, enabling agents to add tracing, build test sets, understand execution traces, and construct agentic workflows without requiring developers to know LangChain internals.

Key technical details:

LangSmith Skills capabilities:

• Tracing integration: Agents can add LangSmith tracing to codebases by invoking CLI commands—no manual SDK integration required
• Trace analysis: Agents query and interpret LangSmith traces to debug issues, understand execution paths, and identify performance bottlenecks
• Test set creation: Agents build evaluation test sets from production traces, converting real behavior into regression tests
• Evaluation setup: Agents configure evaluators, define metrics, and run evaluation pipelines through CLI

LangChain Skills capabilities:

• Agent construction: Agents understand how to build agents using LangChain's frameworks (ReAct, Tool Calling, LangGraph workflows)
• Chain composition: Agents compose chains, define memory systems, and structure agentic workflows
• Integration patterns: Agents know how to integrate with vector stores, retrieval systems, and external tools
• Framework navigation: Agents understand LangChain's API surface and can select appropriate abstractions for different use cases

The CLI architecture: Instead of teaching agents LangChain internals through documentation or examples, the skills packages provide executable interfaces. Agents invoke CLI commands that wrap complex operations:

• langsmith trace add → adds tracing to a codebase
• langsmith trace analyze → interprets execution traces
• langchain agent build --pattern react → scaffolds ReAct agent
• langchain memory configure --type buffer → sets up conversation memory

Why skills matter more than documentation: Documentation teaches humans how to use a framework. Skills teach agents how to execute tasks within a framework. The distinction: agents don't need to "understand" LangChain concepts; they need to invoke correct CLI commands. Skills abstract away complexity.

The composability pattern: These skills extend the Feb 21 pattern (Vercel's 69,000+ agent skills marketplace). LangChain's approach: package domain expertise as executable skills rather than requiring agents to learn through documentation or examples. The architectural shift: agent capabilities expand through skills composition, not through better prompts or bigger context windows.

Why it matters for PMs: This documents a reference architecture for making frameworks agent-usable: don't just publish documentation—ship executable skills packages that agents can invoke. For PMs building developer tools, the question is: can agents use your product directly, or do they need human mediation? The skills pattern suggests agent-first tooling requires CLI interfaces, not just API docs.

Critical questions:

• What's the error recovery pattern when agents invoke CLI commands incorrectly—do they get actionable feedback or just stack traces?
• How do skills packages stay synchronized with framework evolution—does a breaking change in LangChain break all agent-generated code using old skills?
• Can agents compose multiple skills packages (LangChain + LangSmith + external frameworks) without conflicts?
• What's the security model—can agents invoke arbitrary CLI commands or are there permission boundaries?
• How do you version skills packages when underlying framework APIs change?

Action you could take today: If you're building developer tools, audit whether agents can use your product directly. Can an agent add your SDK to a project, configure it, and invoke core features—without requiring a human to read documentation? If not, consider packaging your API as executable skills with CLI interfaces rather than relying on documentation alone.

Vercel - Model Context Protocol (MCP) Apps Support#

Source: https://vercel.com/changelog/mcp-apps-support-on-vercel Credibility: High (first-party infrastructure launch)

What happened: Vercel added support for Model Context Protocol (MCP) apps—enabling agents to expose and invoke capabilities through a standardized protocol. MCP, developed by Anthropic, defines how agents discover, access, and compose tools across different systems. Vercel's implementation allows developers to deploy MCP-compatible apps on Vercel's infrastructure, making agent capabilities discoverable and composable at the platform level.

Key MCP patterns:

What MCP provides:

• Tool discovery: Agents can query which capabilities an MCP app exposes (available functions, data sources, integrations)
• Standardized invocation: Agents invoke tools through consistent interface regardless of underlying implementation
• Composability: Multiple MCP apps can be combined; agents coordinate across tools from different providers
• Context sharing: MCP apps can share context (conversation history, user preferences, session state) following protocol specifications

Why standardization matters: Without MCP, every agent tool requires custom integration—agents need provider-specific APIs, authentication patterns, and invocation semantics. MCP abstracts these differences. The implication: agent tool ecosystems can grow without N×M integration complexity (N tools × M agent frameworks).

The Vercel implementation: Vercel's MCP support enables deploying MCP-compatible apps as serverless functions. When agents query Vercel's infrastructure, they discover available MCP apps and invoke them through the protocol. This extends Vercel's agent infrastructure (Sandboxes from Jan 31, AI Gateway from Feb 21, Skills from Feb 21) with a standards layer.

The convergence signal: LangChain ships skills packages (proprietary format) while Vercel adds MCP support (open protocol). Both solve the same problem: making agent capabilities discoverable and composable. The tension: proprietary ecosystems (LangChain Skills) versus open standards (MCP). The outcome determines whether agent tooling fragments (each framework with custom skill format) or converges (MCP as universal protocol).

Why it matters for PMs: This reveals the architectural choice for agent platforms: build proprietary skill ecosystems (more control, faster iteration) or adopt open protocols (broader ecosystem, less lock-in). For PMs building agent products, the question is: do you bet on platform-specific skills or protocol-based interoperability? The answer affects integration complexity and ecosystem growth potential.

Critical questions:

• What percentage of agent tools will adopt MCP versus custom integrations—is this standard gaining traction or staying niche?
• How does MCP handle authentication and permissions—can agents invoke tools without exposing credentials?
• What's the performance overhead of MCP versus direct API calls—does standardization add latency?
• Can MCP apps share state across invocations—or is each invocation stateless?
• How do you version MCP apps when protocol capabilities evolve?

Action you could take today: If you're building agent tools, research MCP specification and evaluate whether adopting the protocol expands your addressable market (agents from any framework can use your tool) versus requiring proprietary integrations (limiting adoption to specific frameworks). The decision affects integration complexity and ecosystem reach.

Teresa Torres - Stakeholder Management: Show Your Work, Do Your Job#

Source: https://www.producttalk.org/stakeholder-management/ Credibility: High (detailed PM craft framework with concrete practices)

What happened: Teresa published a stakeholder management framework centered on "show your work, do your job"—arguing that stakeholder conflict stems from lack of visibility into product decisions, not disagreement on strategy. The insight: when stakeholders understand how decisions were made (showing your work), they trust the process even when they disagree with outcomes.

Key stakeholder management patterns:

The "show your work" practice: Instead of presenting conclusions ("we're building feature X"), show the reasoning path:

• Evidence gathered: customer interviews, usage data, competitive analysis
• Assumptions tested: which hypotheses were validated or invalidated
• Alternatives considered: what other options were evaluated and why they were rejected
• Trade-offs made: what you're optimizing for and what you're sacrificing

Why this prevents conflict: Stakeholders rarely argue with decisions when they understand the reasoning. Conflict arises when decisions appear arbitrary or uninformed. Showing work makes the decision-making process transparent, shifting conversations from "I disagree with your conclusion" to "I disagree with your assumptions" (which is addressable through data).

The "do your job" boundary: After showing your work, you still own the decision. Stakeholders can provide input, but they can't make the call. The boundary: inform, don't abdicate. This prevents decision paralysis while maintaining stakeholder trust.

Common failure modes Teresa identifies:

1. Hiding work to avoid scrutiny: PMs who fear stakeholder pushback hide their reasoning, presenting only conclusions. This creates suspicion ("what aren't they telling us?") and undermines trust.

2. Over-indexing on stakeholder opinions: PMs who show work but then defer to whoever has the strongest opinion. This destroys accountability—when everyone's input is weighted equally, no one owns outcomes.

3. Show-and-tell without synthesis: PMs who dump data on stakeholders without interpretation. Raw evidence without analysis creates confusion, not clarity.

The weekly practice: Teresa recommends a weekly stakeholder update (written, not meetings) covering:

• This week's discoveries: customer interviews, experiments, data analysis
• How this updates our understanding: what changed in our thinking
• Next week's focus: what we're investigating next
• Help needed: specific asks (introductions, resources, decisions)

Why it matters for PMs: This continues the product craft pattern from previous updates (Feb 19 Teresa's AI for opportunity trees, Feb 12 organizational AI adoption). The message: PM effectiveness depends more on process visibility than persuasion skills. For PMs managing stakeholder relationships, the question is: do you show your work transparently, or hide reasoning until decisions are final?

Critical questions:

• How do you balance transparency with speed—does showing all work slow decision-making?
• What's the right cadence for stakeholder updates—weekly risks over-communication, monthly risks losing stakeholders?
• How do you handle stakeholders who use "show your work" as veto power—demanding endless evidence before agreeing?
• When do you escalate stakeholder disagreements versus pushing through based on your judgment?

Action you could take today: Draft one stakeholder update using Teresa's format: what you discovered this week, how it changed your thinking, what you're focusing on next, and what help you need. Send it to your key stakeholders. This establishes the pattern of transparent decision-making without requiring a process overhaul.