Windsurf Replaces Credits with Quotas & LangChain Ships Agent Sandboxes

Windsurf - Pricing Restructure: Credits to Quotas with New Max Plan#

Source: https://windsurf.com/blog/windsurf-pricing-plans Credibility: High (first-party pricing change with detailed plan comparison)

What happened: Windsurf replaced its credit-based pricing system with industry-standard quotas across Free, Pro, and Teams plans, and launched a new Max plan for power users. The change affects how users pay for AI coding assistance—instead of buying credits that deplete based on model usage and reasoning levels, users now get predictable monthly quotas. Free plan increases from 2,000 to unlimited basic requests; Pro adds 500 premium requests monthly; Max offers 2,500 premium requests monthly; Teams remains at 500 per user.

Key technical details:

Old system (credit-based):

• Users purchased credits
• Different models and reasoning levels consumed different credit amounts
• High reasoning tasks depleted credits faster
• Unpredictable monthly costs based on usage patterns
• Users had to monitor credit balance and top up

New system (quota-based):

• Free plan: Unlimited basic AI requests (previously 2,000 credits)
• Pro plan ($10/month): 500 premium requests + unlimited basic
• Max plan ($40/month, new): 2,500 premium requests + unlimited basic
• Teams plan ($20/user/month): 500 premium requests per user + unlimited basic
• Quotas reset monthly
• Clear distinction: basic requests (simple tasks) vs. premium requests (complex reasoning, code generation)

What counts as premium vs. basic:

• Premium: Code generation, complex refactoring, multi-file edits, deep reasoning tasks
• Basic: Simple suggestions, completions, documentation lookups, minor edits
• Windsurf automatically routes tasks to appropriate tier based on complexity

The pricing model shift:

Credits created uncertainty—users couldn't predict monthly costs because credit consumption varied by task complexity. Quotas provide predictable pricing:

• Developers know exactly how many complex tasks they can run monthly
• No mid-month surprises or credit top-ups
• Easier to budget for team usage

Why this matters beyond pricing: This documents the maturation pattern for AI coding tools. Early-stage products experiment with novel pricing (credits, tokens, usage-based). As products mature and user bases grow, they converge on predictable SaaS pricing (monthly quotas, tiered plans). The Max plan specifically targets power users willing to pay 4x Pro price for 5x premium quota—validating that high-usage developers exist and will pay for capacity.

The competitive positioning:

• GitHub Copilot: Flat $10/month unlimited
• Cursor: $20/month with usage limits
• Windsurf: $10 Pro (500 premium/month), $40 Max (2,500 premium/month)

Windsurf's tiering enables price discrimination: casual users pay $10, power users pay $40. This differs from Cursor's single tier and GitHub's unlimited model. The bet: quota-based pricing with explicit power-user tier captures more revenue than flat pricing.

Why it matters for PMs: This extends the pricing evolution pattern from Feb 28 (Wispr Flow's team pricing restructure). The message: as AI products mature, pricing models converge on predictable quotas rather than consumption-based systems. For PMs building AI features, the question becomes: when do you move from usage-based pricing (aligned with costs) to quota-based pricing (aligned with value)? The answer seems to be: when users complain about unpredictability and budget uncertainty.

Critical questions:

• What's the actual premium request usage distribution—do most Pro users stay under 500, or do many hit the limit?
• How does Windsurf classify tasks as basic vs. premium—is it deterministic or model-predicted?
• What happens when users exceed quotas—does the tool stop working, throttle, or downgrade to basic tier?
• What percentage of users will upgrade to Max versus stay on Pro?
• Does the Free plan's unlimited basic requests create a long-tail adoption funnel or just free riders?

Action you could take today: If you're building AI features with consumption-based pricing, survey your users about pricing predictability. Ask: "Do you know what you'll spend this month?" If >30% say no, that's signal quota-based pricing could reduce churn. Test with a cohort: offer flat monthly pricing versus usage-based, measure retention and willingness to pay.

LangChain - Polly AI Assistant Generally Available & LangSmith Sandboxes for Agent Code Execution#

Source: https://blog.langchain.com/polly-langsmith-ga/ and https://blog.langchain.com/introducing-langsmith-sandboxes-secure-code-execution-for-agents/ Credibility: High (first-party product launches with technical implementation)

What happened: LangChain shipped two major features: Polly (AI debugging assistant) is now generally available across LangSmith, and LangSmith Sandboxes enable secure agent code execution in private preview. Polly provides AI-powered debugging for agentic traces—analyzing failures, suggesting fixes, and explaining agent behavior. Sandboxes give agents secure, isolated environments to run code programmatically—one line of code creates a sandbox where agents execute arbitrary code safely.

Key technical details:

Polly capabilities:

• Trace analysis: Reads deep agent traces (hundreds of steps) and identifies failure points
• Context extraction: Surfaces relevant context from traces (which prompt caused failure, what inputs triggered it)
• Fix suggestions: Recommends specific changes to prompts, agent logic, or orchestration
• Natural language debugging: Users ask "why did this agent fail?" and Polly explains root causes
• Available everywhere: Works across LangSmith's tracing UI, evaluation tools, and production monitoring

LangSmith Sandboxes capabilities:

• Single-line initialization: sandbox = client.create_sandbox() creates isolated execution environment
• Arbitrary code execution: Agents run Python, Node.js, or shell commands without escaping sandbox
• Resource isolation: CPU, memory, filesystem access controlled per sandbox
• Integration with LangSmith tracing: All sandbox executions traced for debugging and evaluation
• Programmatic lifecycle: Agents create, use, and destroy sandboxes as needed
• Now in private preview: Early access available

The debugging workflow transformation:

Traditional agent debugging:

Agent fails → developer reads trace manually → guesses root cause → tries fix → repeats

With Polly:

Agent fails → Polly reads trace → identifies root cause → suggests specific fix → developer applies

The secure execution pattern:

Traditional agent platforms run code in shared environments or rely on external services. LangSmith's approach: make sandboxes a first-class primitive agents control directly.

Instead of:

Agent → asks human to run code → waits for results

Agents now:

Agent → creates sandbox → runs code → interprets results → destroys sandbox

Why sandboxes enable new workflows: Agents often need to test theories, run experiments, or validate assumptions through code execution. Without sandboxes, agents either:

1. Ask humans to run code (breaking automation)
2. Run code in shared environments (security/isolation risk)
3. Use external services like Replicate or Modal (latency, cost, limited control)

Sandboxes remove these constraints. Agents can iterate rapidly on code changes, test hypotheses, and validate solutions—all within secure, disposable environments.

The convergence pattern: This continues the infrastructure convergence from Mar 18 (LangChain sandboxes and Open SWE framework). The broader pattern:

• Vercel shipped Sandboxes (Jan 31)
• Replit built agent runtime (Feb 21)
• LangChain adds sandboxes and coding agent framework (Mar 18)
• LangChain ships Polly debugging assistant (Mar 19)

The implication: autonomous agents require secure execution primitives AND debugging tooling. Infrastructure providers racing to provide both.

Why it matters for PMs: This documents the infrastructure requirements for production agent deployments. For PMs building agent products, the question shifts from "how do we safely run agent code?" to "which sandbox provider AND which debugging tools do we integrate?" The dual requirements: execution security (sandboxes) and operational visibility (debugging assistants like Polly).

Critical questions:

• What's the resource limit per sandbox—can agents run heavy workloads or only lightweight scripts?
• How does Polly handle privacy—does it analyze sensitive production traces, and where is that data stored?
• What's the latency overhead—how long to spin up sandbox, run code, get results, destroy sandbox?
• Can Polly suggest fixes for custom agent architectures, or only LangChain/LangGraph patterns?
• How does pricing work for sandboxes—per-sandbox, per-execution-minute, per-resource-consumption?

Action you could take today: If you're building agents that need code execution, request LangSmith Sandboxes private preview access. Test the end-to-end workflow: agent creates sandbox, runs code, interprets results, destroys sandbox. Measure: latency (time from sandbox creation to first code execution), resource limits (can you run LLMs inside sandboxes?), and error recovery (what happens when agent code crashes?). This reveals whether sandboxes enable your autonomous workflows or just add infrastructure complexity.

Teresa Torres - How Medable Uses Agentic AI to Accelerate Clinical Trials#

Source: https://www.producttalk.org/building-agent-studio-medable/ Credibility: High (detailed case study with concrete product patterns)

What happened: Teresa published a case study on Medable's Agent Studio—a product that uses agentic AI to automate clinical trial operations workflows. The insight: clinical trials involve hundreds of repetitive, rules-based tasks (patient enrollment checks, data validation, compliance monitoring) that agents can handle autonomously, freeing clinical teams for high-judgment work. Medable built an agent framework that non-technical users can configure to automate domain-specific workflows.

Key product patterns:

What Agent Studio automates:

• Patient enrollment validation: Agents check eligibility criteria against patient records, flag disqualifications
• Data quality checks: Agents validate clinical data completeness, consistency, accuracy across systems
• Compliance monitoring: Agents audit processes against regulatory requirements, flag violations
• Workflow orchestration: Agents coordinate tasks across teams (notify doctors, schedule follow-ups, update records)

The configuration approach:

• No-code agent builder: Clinical operations teams configure agents through UI, not code
• Domain-specific templates: Pre-built agents for common clinical trial workflows
• Rules and logic editor: Teams define eligibility criteria, validation rules, escalation paths
• Integration layer: Agents connect to EHR systems, trial management platforms, regulatory databases

Why this differs from general agent platforms: Most agent platforms (LangChain, LangGraph) target developers building custom agents. Agent Studio targets clinical operations teams who need agents but can't write code. The product abstracts agent architecture behind domain-specific interfaces.

The workflow transformation:

Traditional clinical trial operations:

Coordinator receives patient data → manually checks eligibility → validates data quality → updates trial system → repeats for every patient

With Agent Studio:

Agent receives patient data → automatically validates eligibility → flags data issues → updates systems → escalates edge cases to human

Production example from case study:

1. Patient submits enrollment application
2. Agent checks application completeness (all required fields present?)
3. Agent validates eligibility criteria against trial protocol (age, medical history, exclusions)
4. Agent cross-references patient records across multiple systems
5. Agent flags disqualifications or missing data, notifies coordinator
6. Coordinator reviews only flagged cases (not every application)
7. Agent updates trial management system with enrollment decision

Why this matters organizationally: This extends the organizational AI adoption pattern from Mar 5 (Momental's strategy conflict detection). The message: agents enable new governance patterns—not just "work faster" but "automate repetitive workflows that humans shouldn't do manually." For clinical trials, this means coordinators focus on edge cases and high-judgment decisions, while agents handle rules-based validation.

Why it matters for PMs: This documents a reference architecture for domain-specific agent products: abstract agent complexity behind no-code interfaces, provide domain templates, enable non-technical users to configure workflows. For PMs building agent products, the question becomes: can your target users configure agents themselves, or do they need developers as intermediaries? If they can't configure agents, you're selling to developers, not end users.

Critical questions:

• What's the error rate—how often do agents make incorrect eligibility or validation decisions?
• How do clinical teams audit agent decisions for regulatory compliance?
• What happens when agents encounter ambiguous cases—do they escalate to humans or make calls?
• Can agents explain their decisions in regulatory-compliant language?
• At what scale does this provide ROI—how many trials does a customer need before Agent Studio pays for itself?

Action you could take today: Audit your product's workflows for repetitive, rules-based tasks that require multiple system checks. If you find workflows where humans copy data between systems, validate against rules, or flag exceptions—those are agent automation candidates. Prototype: can an agent handle 80% of the task volume, escalating only ambiguous cases? If yes, that's your agent product entry point.