Skip to content

fix(ai): give Claude Agent SDK generations their tool results and every output block - #1256

Merged
marandaneto merged 1 commit into
PostHog:mainfrom
MaiAditya:fix/claude-agent-sdk-tool-results
Nov 16, 2026
Merged

marandaneto merged 1 commit into
PostHog:mainfrom
MaiAditya:fix/claude-agent-sdk-tool-results

Conversation

@MaiAditya

Copy link
Copy Markdown
Contributor

💡 Motivation and Context

With the Claude Agent SDK integration (PostHogClaudeAgentProcessor.query and PostHogClaudeSDKClient), a run that uses tools produces $ai_generation events with wrong content:

  • The generation after a tool call has no $ai_input. The tool results never show up on any event.
  • $ai_output_choices keeps only the last block of a response. When the model writes "Reading the file." and then calls a tool, the text is lost. With two tool calls, only the second one is kept.

The cause is the order in which the Claude Code CLI sends messages. I checked it by running the bundled CLI (2.1.212, from claude-agent-sdk 0.2.121) against a local fake Messages API:

StreamEvent message_start
AssistantMessage [TextBlock('Reading.')]
AssistantMessage [ToolUseBlock(toolu_1, Read)]
AssistantMessage [ToolUseBlock(toolu_2, Read)]
StreamEvent message_delta
StreamEvent message_stop
UserMessage [ToolResultBlock(toolu_2)]
UserMessage [ToolResultBlock(toolu_1)]
StreamEvent message_start
...
  • Output: each content block arrives as its own AssistantMessage, and the processor replaced pending_output on every one.
  • Input: the comment in _instrument_query expected tool results before message_stop, and queued input was promoted at message_stop. Tool results actually arrive after message_stop, so they were promoted one generation late, and the last results were lost.
  • Parallel tool calls: each result is its own UserMessage, and each one replaced the previous.

The fix, applied in both the processor and the client:

  • Append output blocks for the current generation.
  • Append tool results to the queued input. Results that come in separate UserMessages are merged into one user message.
  • Promote queued input when the next generation starts (message_start), so it no longer matters which side of message_stop the results land on.
  • A generation with nothing queued has no $ai_input, as on main. Input belongs to one generation only; it is not repeated on a follow-up generation that got no tool results.
  • If a request is restarted before its message_stop (a retry), the partial output of the unfinished attempt is dropped, and the retry keeps the attempt's input.
  • Without stream events, the result fallback reports every block of the final assistant turn (the blocks after the last tool result). On main it reported only the last block; it never carries output from earlier turns.
  • Leave messages a subagent sends (parent_tool_use_id set) out of the main generations' input and output, and don't let a subagent's message_start take the main generation's queued tool results. The CLI forwards those while the tool that started the subagent is running. Their tool spans are still emitted as before.

PostHogClaudeSDKClient.query() now also clears any input and output left over from the previous turn.

Why not group by AssistantMessage.message_id? It doesn't exist in claude-agent-sdk 0.1.50, the minimum version in pyproject.toml, so the stream events are the only generation boundary available on every supported version.

💚 How did you test it?

  • New tests in posthog/test/ai/claude_agent_sdk/test_client.py. Each test runs against both the processor and PostHogClaudeSDKClient, using the message order recorded from the CLI:

    • every text and tool-use block lands in the first generation's output;
    • both parallel tool results become the second generation's input;
    • subagent messages don't leak into either generation, and a subagent's stream events don't take queued tool results;
    • a retried request reports only the attempt that finished;
    • a generation with no queued input reports no input;
    • without stream events, the fallback reports every block of the final turn only, and the client doesn't carry output into the next query().

    The first two fail on main, and the subagent test fails if the parent_tool_use_id check is removed (it also fails on main).

  • The existing tests that use the old order still pass, including the multi-turn client test where tool results arrive before message_stop. pytest posthog/test/ai: 1625 passed, 15 skipped.

  • End to end with the real CLI and no API key: I ran the bundled claude binary through PostHogClaudeAgentProcessor.query() with ANTHROPIC_BASE_URL pointed at a small local server that streams a text block plus two Read tool calls, then a final answer. On main, generation 2 had $ai_input = null and generation 1's output was just the second tool call. With this change, generation 1's output has Reading. plus both tool calls, and generation 2's input has both tool results.

  • Edge cases I considered:

    • empty or unrecognised UserMessage content still doesn't clear queued results;
    • a new client.query() turn uses its own prompt;
    • a retried request keeps its input, because the unfinished attempt never consumed it.
  • Checks: ruff format --check, ruff check, mypy | mypy-baseline filter (no new violations), and make public_api_check (up to date).

📝 Checklist

  • All commits are signed (see Commit signing)
  • I reviewed the submitted code.
  • I added tests to verify the changes.
  • I updated the docs if needed.
  • No breaking change or entry added to the changelog.

If releasing new changes

  • Ran sampo add to generate a changeset file (written by hand in the same format, as sampo isn't installed here)

🤖 Agent context

Autonomy: Human-driven (agent-assisted)

  • I used Claude Code (Anthropic) to read the Claude Agent SDK integration and to write a small fake Messages API server, so I could run the bundled CLI offline and record the real message order. It also drafted the fix and the tests.
  • Choices made along the way:
    • Promote queued input at message_start rather than special-casing the new order, so both orders work.
    • Keep the public format_assistant_blocks re-exports as they are, so the API snapshot doesn't change.
    • Reset output at message_start only when the previous request never finished, because an existing test sends the AssistantMessage after message_stop.
    • Skip subagent messages using parent_tool_use_id.
  • I reviewed every change and ran the tests and the end-to-end CLI check myself, and I can explain the change without the tool.

…ry output block

The Claude Code CLI sends each content block of a response as its own
AssistantMessage, and each tool result as its own UserMessage after
the generation's message_stop. The processor and PostHogClaudeSDKClient
replaced the pending output on every AssistantMessage and promoted
queued input at message_stop, so a generation kept only its last output
block and the generation after a tool call had no $ai_input.

Append output blocks per generation, append tool results to the queued
input, and promote queued input when the next main-agent generation
starts. A generation with nothing queued still has no input, as before.
A request that is restarted before its message_stop drops its partial
output. Without stream events, the result fallback reports every block
of the final assistant turn. Messages a subagent sends
(parent_tool_use_id set) stay out of the main generations' content.
@MaiAditya
MaiAditya requested a review from a team as a code owner November 15, 2026 15:38

@marandaneto marandaneto left a comment

Copy link
Copy Markdown
Member

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

The code looks good; no qualifying findings. Verdict: correct.

Thank you for your contribution!

@github-actions

Copy link
Copy Markdown
Contributor

SDK performance: posthog-python

Benchmarks completed. No changes flagged for review.

Flags require at least a 5% change in the median and all six pairs agreeing on direction. This is a noise filter, not proof of a performance change or a CI gate.

View all results
Test Measurement Before PR With PR Change Assessment
Capture and deliver events (32-byte payload, burst)
Shard: capture
Managed heap after settling — — — unavailable; base:​ unsupported; head:​ unsupported; base:​ CPython has no uninstrumented total managed-heap byte counter; tracing would distort this RSS pass.​; head:​ CPython has no uninstrumented total managed-heap byte counter; tracing would distort this RSS pass.​
Capture and deliver events (4,096-byte payload, burst)
Shard: capture
Managed heap after settling — — — unavailable; base:​ unsupported; head:​ unsupported; base:​ CPython has no uninstrumented total managed-heap byte counter; tracing would distort this RSS pass.​; head:​ CPython has no uninstrumented total managed-heap byte counter; tracing would distort this RSS pass.​
Capture and deliver events (32-byte payload, steady)
Shard: capture
Managed heap after settling — — — unavailable; base:​ unsupported; head:​ unsupported; base:​ CPython has no uninstrumented total managed-heap byte counter; tracing would distort this RSS pass.​; head:​ CPython has no uninstrumented total managed-heap byte counter; tracing would distort this RSS pass.​
Capture and deliver events (4,096-byte payload, steady)
Shard: capture
Managed heap after settling — — — unavailable; base:​ unsupported; head:​ unsupported; base:​ CPython has no uninstrumented total managed-heap byte counter; tracing would distort this RSS pass.​; head:​ CPython has no uninstrumented total managed-heap byte counter; tracing would distort this RSS pass.​
Queue an event (32-byte payload)
Shard: capture
Allocated memory per operation — — — unavailable; base:​ unsupported; head:​ unsupported; base:​ Background preparation has no public completion boundary before flush; see capture.​drain for full-pipeline allocations.​; head:​ Background preparation has no public completion boundary before flush; see capture.​drain for full-pipeline allocations.​
Queue an event (32-byte payload)
Shard: capture
Allocations per operation — — — unavailable; base:​ unsupported; head:​ unsupported; base:​ Background preparation has no public completion boundary before flush; see capture.​drain for full-pipeline allocations.​; head:​ Background preparation has no public completion boundary before flush; see capture.​drain for full-pipeline allocations.​
Queue an event (4,096-byte payload)
Shard: capture
Allocated memory per operation — — — unavailable; base:​ unsupported; head:​ unsupported; base:​ Background preparation has no public completion boundary before flush; see capture.​drain for full-pipeline allocations.​; head:​ Background preparation has no public completion boundary before flush; see capture.​drain for full-pipeline allocations.​
Queue an event (4,096-byte payload)
Shard: capture
Allocations per operation — — — unavailable; base:​ unsupported; head:​ unsupported; base:​ Background preparation has no public completion boundary before flush; see capture.​drain for full-pipeline allocations.​; head:​ Background preparation has no public completion boundary before flush; see capture.​drain for full-pipeline allocations.​
Evaluate 1,000 flags under concurrent load
Shard: flags-memory
Managed heap after settling — — — unavailable; base:​ unsupported; head:​ unsupported; base:​ CPython has no uninstrumented total managed-heap byte counter; tracing would distort this RSS pass.​; head:​ CPython has no uninstrumented total managed-heap byte counter; tracing would distort this RSS pass.​
Refresh 1,000 flag definitions
Shard: flags-memory
Managed heap after settling — — — unavailable; base:​ unsupported; head:​ unsupported; base:​ CPython has no uninstrumented total managed-heap byte counter; tracing would distort this RSS pass.​; head:​ CPython has no uninstrumented total managed-heap byte counter; tracing would distort this RSS pass.​
Capture and deliver events (32-byte payload, burst)
Shard: capture
Allocated memory per operation 115.72 KiB/op 115.72 KiB/op <0.1% more memory Not flagged
Capture and deliver events (32-byte payload, burst)
Shard: capture
Allocations per operation 1,107.6 count/op 1,107.61 count/op <0.1% more Not flagged
Capture and deliver events (32-byte payload, burst)
Shard: capture
Time per operation 63.06 µs/op 63.15 µs/op 0.2% more time Not flagged
Capture and deliver events (32-byte payload, burst)
Shard: capture
Idle process memory (RSS) 36.23 MiB 36.24 MiB <0.1% more memory Not flagged
Capture and deliver events (32-byte payload, burst)
Shard: capture
Observed peak process memory (RSS) 37.95 MiB 37.96 MiB <0.1% more memory Not flagged
Capture and deliver events (32-byte payload, burst)
Shard: capture
Process memory after settling (RSS) 37.95 MiB 37.96 MiB <0.1% more memory Not flagged
Capture and deliver events (32-byte payload, burst)
Shard: capture
Process CPU time per operation 66.41 µs/op 65.76 µs/op 1% less time Not flagged
Capture and deliver events (32-byte payload, burst)
Shard: capture
Lifetime peak process memory (RSS) 40.37 MiB 40.37 MiB No observed change Not flagged
Capture and deliver events (4,096-byte payload, burst)
Shard: capture
Allocated memory per operation 168.28 KiB/op 168.28 KiB/op <0.1% less memory Not flagged
Capture and deliver events (4,096-byte payload, burst)
Shard: capture
Allocations per operation 1,100.59 count/op 1,100.58 count/op <0.1% fewer Not flagged
Capture and deliver events (4,096-byte payload, burst)
Shard: capture
Time per operation 86.77 µs/op 86.99 µs/op 0.3% more time Not flagged
Capture and deliver events (4,096-byte payload, burst)
Shard: capture
Idle process memory (RSS) 41.11 MiB 41.1 MiB <0.1% less memory Not flagged
Capture and deliver events (4,096-byte payload, burst)
Shard: capture
Observed peak process memory (RSS) 46.19 MiB 46.19 MiB No observed change Not flagged
Capture and deliver events (4,096-byte payload, burst)
Shard: capture
Process memory after settling (RSS) 46.19 MiB 46.19 MiB No observed change Not flagged
Capture and deliver events (4,096-byte payload, burst)
Shard: capture
Process CPU time per operation 83.99 µs/op 84.26 µs/op 0.3% more time Not flagged
Capture and deliver events (4,096-byte payload, burst)
Shard: capture
Lifetime peak process memory (RSS) 51.02 MiB 50.96 MiB 0.1% less memory Not flagged
Capture and deliver events (32-byte payload, steady)
Shard: capture
Allocated memory per operation 119.85 KiB/op 119.86 KiB/op <0.1% more memory Not flagged
Capture and deliver events (32-byte payload, steady)
Shard: capture
Allocations per operation 1,147.47 count/op 1,147.5 count/op <0.1% more Not flagged
Capture and deliver events (32-byte payload, steady)
Shard: capture
Time per operation 72.96 µs/op 73.1 µs/op 0.2% more time Not flagged
Capture and deliver events (32-byte payload, steady)
Shard: capture
Idle process memory (RSS) 36.12 MiB 36.17 MiB 0.1% more memory Not flagged
Capture and deliver events (32-byte payload, steady)
Shard: capture
Observed peak process memory (RSS) 36.21 MiB 36.26 MiB 0.2% more memory Not flagged
Capture and deliver events (32-byte payload, steady)
Shard: capture
Process memory after settling (RSS) 36.21 MiB 36.26 MiB 0.2% more memory Not flagged
Capture and deliver events (32-byte payload, steady)
Shard: capture
Process CPU time per operation 75.8 µs/op 75.75 µs/op <0.1% less time Not flagged
Capture and deliver events (32-byte payload, steady)
Shard: capture
Lifetime peak process memory (RSS) 40.37 MiB 40.37 MiB No observed change Not flagged
Capture and deliver events (4,096-byte payload, steady)
Shard: capture
Allocated memory per operation 172.74 KiB/op 172.74 KiB/op <0.1% more memory Not flagged
Capture and deliver events (4,096-byte payload, steady)
Shard: capture
Allocations per operation 1,140.33 count/op 1,140.34 count/op <0.1% more Not flagged
Capture and deliver events (4,096-byte payload, steady)
Shard: capture
Time per operation 91.09 µs/op 91.32 µs/op 0.3% more time Not flagged
Capture and deliver events (4,096-byte payload, steady)
Shard: capture
Idle process memory (RSS) 40.94 MiB 40.97 MiB <0.1% more memory Not flagged
Capture and deliver events (4,096-byte payload, steady)
Shard: capture
Observed peak process memory (RSS) 40.94 MiB 40.97 MiB <0.1% more memory Not flagged
Capture and deliver events (4,096-byte payload, steady)
Shard: capture
Process memory after settling (RSS) 40.94 MiB 40.97 MiB <0.1% more memory Not flagged
Capture and deliver events (4,096-byte payload, steady)
Shard: capture
Process CPU time per operation 89.8 µs/op 88.54 µs/op 1.4% less time Not flagged
Capture and deliver events (4,096-byte payload, steady)
Shard: capture
Lifetime peak process memory (RSS) 41.32 MiB 41.38 MiB 0.1% more memory Not flagged
Queue an event (32-byte payload)
Shard: capture
Caller-thread CPU time per operation 43.04 µs/op 43.02 µs/op <0.1% less time Not flagged
Queue an event (32-byte payload)
Shard: capture
Time per operation 43.05 µs/op 43.02 µs/op <0.1% less time Not flagged
Queue an event (4,096-byte payload)
Shard: capture
Caller-thread CPU time per operation 43.26 µs/op 43.47 µs/op 0.5% more time Not flagged
Queue an event (4,096-byte payload)
Shard: capture
Time per operation 43.33 µs/op 43.47 µs/op 0.3% more time Not flagged
Evaluate all 10 flags
Shard: flags-scaling
Allocated memory per operation 226.56 KiB/op 226.56 KiB/op No observed change Not flagged
Evaluate all 10 flags
Shard: flags-scaling
Allocations per operation 2,240.44 count/op 2,240.44 count/op No observed change Not flagged
Evaluate all 10 flags
Shard: flags-scaling
Time per operation 67.19 µs/op 68.4 µs/op 1.8% more time Not flagged
Evaluate all 10 flags
Shard: flags-scaling
Process CPU time per operation 67.18 µs/op 68.41 µs/op 1.8% more time Not flagged
Evaluate all 100 flags
Shard: flags-scaling
Allocated memory per operation 2.17 MiB/op 2.17 MiB/op No observed change Not flagged
Evaluate all 100 flags
Shard: flags-scaling
Allocations per operation 22,014.88 count/op 22,014.88 count/op No observed change Not flagged
Evaluate all 100 flags
Shard: flags-scaling
Time per operation 668.77 µs/op 680.78 µs/op 1.8% more time Not flagged
Evaluate all 100 flags
Shard: flags-scaling
Process CPU time per operation 668.83 µs/op 680.89 µs/op 1.8% more time Not flagged
Evaluate all 1,000 flags
Shard: flags-scaling
Allocated memory per operation 21.69 MiB/op 21.69 MiB/op No observed change Not flagged
Evaluate all 1,000 flags
Shard: flags-scaling
Allocations per operation 219,656.62 count/op 219,656.62 count/op No observed change Not flagged
Evaluate all 1,000 flags
Shard: flags-scaling
Time per operation 7.57 ms/op 7.35 ms/op 3% less time Not flagged
Evaluate all 1,000 flags
Shard: flags-scaling
Process CPU time per operation 7.57 ms/op 7.35 ms/op 3% less time Not flagged
Evaluate 1,000 flags under concurrent load
Shard: flags-memory
Idle process memory (RSS) 43 MiB 42.93 MiB 0.2% less memory Not flagged
Evaluate 1,000 flags under concurrent load
Shard: flags-memory
Observed peak process memory (RSS) 43.27 MiB 43.31 MiB <0.1% more memory Not flagged
Evaluate 1,000 flags under concurrent load
Shard: flags-memory
Process memory after settling (RSS) 43.27 MiB 43.31 MiB <0.1% more memory Not flagged
Evaluate 1,000 flags under concurrent load
Shard: flags-memory
Lifetime peak process memory (RSS) 43.21 MiB 43.08 MiB 0.3% less memory Not flagged
Refresh 1,000 flag definitions
Shard: flags-memory
Idle process memory (RSS) 42.07 MiB 41.44 MiB 1.5% less memory Not flagged
Refresh 1,000 flag definitions
Shard: flags-memory
Observed peak process memory (RSS) 42.13 MiB 42.15 MiB <0.1% more memory Not flagged
Refresh 1,000 flag definitions
Shard: flags-memory
Process memory after settling (RSS) 42.11 MiB 42.14 MiB <0.1% more memory Not flagged
Refresh 1,000 flag definitions
Shard: flags-memory
Lifetime peak process memory (RSS) 42.51 MiB 42.55 MiB <0.1% more memory Not flagged
Evaluate one boolean flag
Shard: flags-single
Allocated memory per operation 16.63 KiB/op 16.63 KiB/op No observed change Not flagged
Evaluate one boolean flag
Shard: flags-single
Allocations per operation 164.77 count/op 164.77 count/op No observed change Not flagged
Evaluate one boolean flag
Shard: flags-single
Time per operation 8.76 µs/op 8.74 µs/op 0.2% less time Not flagged
Evaluate one boolean flag
Shard: flags-single
Process CPU time per operation 8.76 µs/op 8.74 µs/op 0.2% less time Not flagged
Evaluate a cohort-filtered flag
Shard: flags-single
Allocated memory per operation 25.49 KiB/op 25.49 KiB/op No observed change Not flagged
Evaluate a cohort-filtered flag
Shard: flags-single
Allocations per operation 241.28 count/op 241.28 count/op No observed change Not flagged
Evaluate a cohort-filtered flag
Shard: flags-single
Time per operation 12.17 µs/op 12.18 µs/op 0.1% more time Not flagged
Evaluate a cohort-filtered flag
Shard: flags-single
Process CPU time per operation 12.17 µs/op 12.18 µs/op 0.1% more time Not flagged
Evaluate a flag (early match)
Shard: flags-single
Allocated memory per operation 40.7 KiB/op 40.7 KiB/op No observed change Not flagged
Evaluate a flag (early match)
Shard: flags-single
Allocations per operation 390.27 count/op 390.27 count/op No observed change Not flagged
Evaluate a flag (early match)
Shard: flags-single
Time per operation 17.01 µs/op 17.13 µs/op 0.7% more time Not flagged
Evaluate a flag (early match)
Shard: flags-single
Process CPU time per operation 17.01 µs/op 17.13 µs/op 0.7% more time Not flagged
Evaluate a flag (late match)
Shard: flags-single
Allocated memory per operation 61.48 KiB/op 61.48 KiB/op No observed change Not flagged
Evaluate a flag (late match)
Shard: flags-single
Allocations per operation 586.27 count/op 586.27 count/op No observed change Not flagged
Evaluate a flag (late match)
Shard: flags-single
Time per operation 24.24 µs/op 24.11 µs/op 0.5% less time Not flagged
Evaluate a flag (late match)
Shard: flags-single
Process CPU time per operation 24.24 µs/op 24.11 µs/op 0.5% less time Not flagged
Evaluate a flag (no match)
Shard: flags-single
Allocated memory per operation 60.11 KiB/op 60.11 KiB/op No observed change Not flagged
Evaluate a flag (no match)
Shard: flags-single
Allocations per operation 569.77 count/op 569.77 count/op No observed change Not flagged
Evaluate a flag (no match)
Shard: flags-single
Time per operation 22.96 µs/op 22.95 µs/op <0.1% less time Not flagged
Evaluate a flag (no match)
Shard: flags-single
Process CPU time per operation 22.96 µs/op 22.95 µs/op <0.1% less time Not flagged
Evaluate a property-filtered flag
Shard: flags-single
Allocated memory per operation 19.93 KiB/op 19.93 KiB/op No observed change Not flagged
Evaluate a property-filtered flag
Shard: flags-single
Allocations per operation 194.28 count/op 194.28 count/op No observed change Not flagged
Evaluate a property-filtered flag
Shard: flags-single
Time per operation 9.83 µs/op 9.84 µs/op <0.1% more time Not flagged
Evaluate a property-filtered flag
Shard: flags-single
Process CPU time per operation 9.83 µs/op 9.84 µs/op <0.1% more time Not flagged
Evaluate a regex-filtered flag
Shard: flags-single
Allocated memory per operation 21.56 KiB/op 21.56 KiB/op No observed change Not flagged
Evaluate a regex-filtered flag
Shard: flags-single
Allocations per operation 199.78 count/op 199.78 count/op No observed change Not flagged
Evaluate a regex-filtered flag
Shard: flags-single
Time per operation 10.38 µs/op 10.38 µs/op <0.1% more time Not flagged
Evaluate a regex-filtered flag
Shard: flags-single
Process CPU time per operation 10.38 µs/op 10.38 µs/op <0.1% more time Not flagged
Evaluate a rollout flag
Shard: flags-single
Allocated memory per operation 15.79 KiB/op 15.79 KiB/op No observed change Not flagged
Evaluate a rollout flag
Shard: flags-single
Allocations per operation 154.77 count/op 154.77 count/op No observed change Not flagged
Evaluate a rollout flag
Shard: flags-single
Time per operation 8.32 µs/op 8.28 µs/op 0.5% less time Not flagged
Evaluate a rollout flag
Shard: flags-single
Process CPU time per operation 8.32 µs/op 8.28 µs/op 0.5% less time Not flagged
Evaluate a multivariate flag
Shard: flags-single
Allocated memory per operation 16.79 KiB/op 16.79 KiB/op No observed change Not flagged
Evaluate a multivariate flag
Shard: flags-single
Allocations per operation 168.77 count/op 168.77 count/op No observed change Not flagged
Evaluate a multivariate flag
Shard: flags-single
Time per operation 9.15 µs/op 9.15 µs/op <0.1% more time Not flagged
Evaluate a multivariate flag
Shard: flags-single
Process CPU time per operation 9.15 µs/op 9.15 µs/op <0.1% more time Not flagged

Values are medians of paired measurements. Not flagged does not mean unchanged. Unavailable means a measurement could not be provided, not zero. Estimated allocation measurements retain their instrumentation uncertainty. RSS measures the whole process, not just SDK allocations; observed peaks are sampled checkpoints. Paired ranges in the diagnostics describe variability, not confidence intervals.

Each shard uses its own runner; compare Before PR against With PR within a row, not across shards.

Compared ec112a6201569e1cf5e9b8827a01793de523f643 → 0940a6af6366c17d70b83192a4ce498ef6871fc4.

Full report and diagnostics

102 metric rows; 102 rows shown in all results. Omitted or shortened data remain in comparison.json, including per-runner environments, resource limits, measurement methods, samples and checkpoints.

@marandaneto
marandaneto merged commit 5340514 into PostHog:main Nov 16, 2026
52 checks passed
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment

Labels

None yet

Projects

None yet

Development

Successfully merging this pull request may close these issues.

2 participants