Jam

@jam analyze the video in jam-abc123 and summarize what the user was trying to accomplish and what went wrong

Based on the video analysis: The user attempted to complete a checkout flow but encountered a payment processing failure. Key observations: (1) User navigated to cart → checkout → payment form over 47 seconds. (2) After entering card details, clicked 'Complete Purchase' three times with no visual feedback. (3) Console shows a 402 error from /api/payments/process at timestamp 00:43. (4) User verbally expressed frustration: 'it's not working again.' The interaction pattern suggests a timeout or validation issue rather than user error.

This example showcases Jam's video analysis capability, which extracts structured insights from screen recordings with user interactions and audio. Requires the Jam to be a video type (not just a screenshot). The AI synthesizes technical signals (console errors, network timing) with behavioral observations (clicks, hesitation, verbal feedback) to diagnose issues faster than manual review.

@jam get console logs and network requests from jam-xyz789 where the status code is 500 or higher

Console logs (4 entries): Two CORS warnings from cdn.example.com at 14:32:18, one React hydration error at 14:32:22, and an unhandled promise rejection at 14:32:31 referencing 'fetchUserProfile'. Network requests (2 failures): GET /api/user/profile returned 503 at 14:32:30 (response time: 8.2s, body: '{"error":"service unavailable"}'), and POST /api/analytics/track returned 504 at 14:32:45 (timeout after 30s). Both requests originated from app.example.com and include full request/response headers in the Jam.

This read-heavy example demonstrates Jam's debugging data retrieval with filtering. The MCP surfaces browser-captured diagnostics that would otherwise require manual DevTools inspection. Note that network request bodies are only available if the user's Jam captured them (privacy settings may limit this). Always call 'Get Jam Details' first to confirm the Jam type and available data before requesting logs or network traces.

@jam get video frames from jam-def456 at the exact moments when console errors occurred, then explain what the user saw on screen

Retrieved 3 frames corresponding to console error timestamps: Frame 1 (00:18): User on login page, email field populated, password field empty—console shows 'Uncaught TypeError: Cannot read property split of undefined' from auth.js:47. Frame 2 (00:52): User on dashboard with loading spinner visible—console shows '401 Unauthorized' from /api/dashboard/widgets. Frame 3 (01:23): User on settings page, modal dialog open—console shows 'ResizeObserver loop limit exceeded'. Visual context: The 401 error coincides with the spinner never resolving, suggesting a session expiration. The other errors appear non-blocking but may contribute to perceived sluggishness.

This synthesis example pairs Jam's frame extraction with AI reasoning to correlate visual UI state with technical errors. Useful for understanding user-facing impact of backend failures. Requires the Jam to be video type and have console logs captured. The 'timestamps_ms' parameter must match actual error times—call 'Get Console Logs' first to identify those timestamps, then request frames.

When Jam MCP replaces the 'can you send a screenshot' loop

A 6-person support team at a B2B SaaS company spends half their triage time asking customers for more context—screenshots, console logs, steps to reproduce. The Jam MCP is built for this exact workflow. When a customer submits a Jam (a video bug report with automatic context capture), the team's AI assistant can call Get Jam Details to pull the full debugging payload, then Get Console Logs and Get Network Requests to diagnose the issue without a back-and-forth. The MCP shines when your support volume is under 200 tickets/week and most bugs are frontend or API-related; above that threshold, you'll want Jam's native integrations with Linear or Jira instead of routing everything through the AI layer. If your team already uses Jam for bug reporting, this MCP turns your shared workspace into a first-pass diagnostic tool that cuts average resolution time by a day.

When this MCP wins for qualitative user research at scale

A 3-person product team at a Series A startup collects 40-60 video Jams per sprint from beta users—feature requests, confusion points, workflow friction. The Analyze Jam Video tool extracts structured summaries (user goals, reported issues, visual observations) from each video without manual transcription. The team's AI assistant can batch-process a week's worth of Jams in one prompt, then surface patterns across the corpus. This works when your feedback is already in Jam format and you need thematic synthesis, not pixel-perfect replay. If you're doing usability testing with controlled tasks, traditional session recording tools (FullStory, Hotjar) give you better heatmaps and funnel analytics. But if your users are already sending Jams and you're drowning in video, this MCP turns your shared workspace into a lightweight research assistant that ships themes to your roadmap doc in under an hour.

When Jam MCP accelerates root-cause analysis for frontend incidents

A 10-person engineering team at a fintech company runs a weekly incident review. When a production bug surfaces, the on-call engineer captures a Jam with full browser context—console errors, network waterfall, session replay. The Jam MCP lets the team's AI assistant pull Get Console Logs and Get Network Requests during the postmortem, cross-reference stack traces with recent deploys, and draft a timeline without switching tools. This is the right call when your incidents are client-side (JavaScript errors, failed API calls, rendering bugs) and your team already uses Jam for internal bug reporting. If your incidents are mostly backend (database locks, queue backlog, infra failures), you need observability tooling (Datadog, Sentry) instead. The MCP's 16 tools cover the full Jam surface area, so if you're already paying for Jam and your postmortems involve replaying user sessions, this integration turns your shared workspace into a collaborative debugger that cuts write-up time from 2 hours to 20 minutes.