SmartPerfetto 1.19.0 Pivots to Pi Agent Core and Releases Perfetto-Skills for Agent-Local Trace Analysis
SmartPerfetto 1.19.0 has been released. Compared with 1.15.1 covered in the previous release notes, the biggest change in this period is that the analysis engine is unified to Pi Agent Core; at the same time, Perfetto has been upgraded, new data analysis capabilities have been added, and many practical issues around TraceDemo multi-round testing have been fixed.
First, here are the notable contents:
- Analysis engine unification: Moved from multiple Agent runtimes to defaulting to Pi Agent Core; Web, CLI, and API share forensic and delivery capabilities. The old model declaration and claim-verification flow has been removed.
- Better analysis experience: Context can be added mid-analysis; source selection is saved per session; long-session evidence readback, budget finalization, connection interruptions, and error messages have been fixed.
- More evidence available: Perfetto upgraded to v59.1, adding process lifecycle and JobScheduler observations; Bitmap, Doze, CPU PMU, camera, and rendering analysis updates.
- Multi-round verification produced concrete results: Synthetic samples, real traces, targeted regression tests, and final release packages each verified. What was completed and what was only partially tested will be explained later.
- If you don't want to install the full product, you can use Perfetto-Skills: Install the standalone Skills into your own Codex, Claude Code, or OpenCode environment to analyze traces in an existing agent setup.
Download 1.19.0 · SmartPerfetto · Perfetto-Skills
This is a standalone update, continuing from the previous release notes, covering 1.16.0 to 1.19.0. Notably, Pi became the default engine in 1.18.0; 1.19.0 continues adding capabilities and fixing issues after that migration.
Version first: what changed over the past month
| Version | Changes covered in this article |
|---|---|
| 1.16.0—1.16.2 | Strengthened units, evidence, and answer delivery; fixed full HTML report contents, offline interaction, and identity recovery. Maintained the declaration and semantic verification flow, later removed in 1.18.0 |
| 1.16.3—1.16.4 | Fixed historical message rendering, idle trace processor collection, CPU/FPS target identity; tidied AI Assistant docking, scaling, narrow panel, and theme behavior |
| 1.17.0 | Synced Perfetto UI, Wasm, trace processor, and SQL knowledge to v59.1; added process start/stop and JobScheduler evidence |
| 1.18.0 | Default engine switched to Pi Agent Core; supports adding information mid-run; removed OpenCode/Qoder execution engines and model declaration verification flow |
| 1.18.1 | Source selection saved per session; can proactively import local Claude Code/Codex gateway configuration; npm package carries Node 24 SQLite native bindings |
| 1.19.0 | Bitmap, Doze, PMU capabilities, and camera/render evidence improvements; continued fixes for Pi budget, tool results, SQL guidance, identity diagnostics, and CLI report delivery |
See the full list in the 1.19.0 Changelog. Below I focus on user-visible changes and the reasons behind them.
New architecture: unified model loop, keeping analysis capabilities in the product
A trace analysis involves several different types of work. The model must understand the question and decide what to investigate next; Skills and SQL must actually fetch data; process identity, time windows, and data sources must stay consistent; and the final conclusions, HTML report, and session results must be delivered.
Previously, maintaining multiple model SDK/runtimes required connecting these tasks across different execution modes. Now the default is Pi Agent Core responsible for model requests and tool loops, while SmartPerfetto continues to own policies, tools, Skills, SQL, identity and permissions, reporting, and sessions. Web, CLI, and API use the same backend analysis capabilities.
The figure shows the change in default execution path. 1.19.0 still keeps hidden fallbacks to the old Claude/OpenAI engines; they are no longer options in the daily configuration UI.
Providers still decide API, endpoint, model, and credentials. When switching engines, existing configuration must retain the original request target; resuming old sessions must not silently send the session to another service just because the active provider changed. Non-migratable old configurations explicitly error. Source authorization, process identity, and trace ownership checks continue to be product-controlled.
Pi here does not automatically gain arbitrary file and shell permissions. SmartPerfetto uses its own analysis tool set; source reading still requires corresponding authorization. See the current runtime architecture for module relationships.
A flow that received a lot of effort was also removed
If you read the previous article, you'll recall it spent considerable space on "answer declaration and verification": the model had to declare conclusions and evidence relationships in a specific format, which the product then parsed, repaired, and verified.
1.16.x continued to fix that flow, including declaration formats, budget-exhaustion recovery, and incomplete citations. But in real model runs, there was still delivery friction between declarations, repairs, and final text; the 1.17.0 release notes also explicitly kept limitations on incomplete reports for startup and sliding exploration runs. By 1.18.0, runtime model declaration and claim-verification flow was removed.
The current direction puts deterministic work into the forensic stage: Skills/SQL provide data, producers explain units, scope, and semantics as much as possible, and the model organizes investigation and interpretation based on that. The backend still guards identity, authorization, budget, and delivery contracts, but it does not package "generated a report" as "every sentence completed causal proof."
I think this trade-off is worth documenting separately. If release notes only list additions, readers might assume the earlier verification capability has accumulated up to now; in fact, there was a clear architectural change.
Add information mid-analysis; continue viewing evidence in long investigations
After analysis has started, users often remember a key piece of information, such as "only look at the second startup" or "this process just restarted." Now context can be added during execution; the UI shows whether the addition is queued, delivered, or failed to apply. It does not guarantee retroactive modification of already completed analysis steps, but users know whether the information entered this run.
Source selection is now saved per session; new sessions start from the most recent selection. When explicitly initiated by the user, third-party gateway configuration from local Claude Code/Codex can be imported; the import reads only the specified config file and confirms via a system dialog. This does not mean that subscribing and logging into Claude Code lets you configure SmartPerfetto directly; valid API credentials are still required.
In long investigations, evidence management also affects experience. The model may first query an overview, then after dozens of tool calls need to look back at the earliest lines. We expanded the capped artifact working set while limiting the lines sent directly into model context, preserving on-demand pagination and readback. This reduces interruptions caused by prematurely evicted evidence while controlling context size. Caching still has capacity and lifecycle limits.
Pi's budget finalization and connection recovery also went through multiple rounds of fixes: leaving room for final conclusions when rounds or context approach limits; recovering retriable service errors and idle stream interruptions according to count, time, round, and known cost constraints; preserving already completed tool results. Cost caps only work for models with known pricing; they should not be interpreted as a hard billing guarantee for all third-party gateways.
New analysis capabilities: first clarify what can be seen
Perfetto v59.1, process lifecycle, and background tasks
1.17.0 synced Perfetto v59.1, including UI/Wasm, pinned trace processor, and generated SQL knowledge. Upstream changes like FrameTimeline layer grouping, heap view navigation, and CPU time also entered the product.
Analysis-side additions include process start context, start latency, exit reason, and state transitions; JobScheduler uses both framework track events and existing ATrace views. When wait duration, cancelled tasks, or ownership information is missing, corresponding limitations are preserved; unknown values are not written as zero.
Bitmap, Doze, CPU PMU
Bitmap analysis now includes the live set shape, size distribution, and large objects of recorded objects in the process. When investigating image memory, you can move from "takes up a lot" to specific distributions. However, recorded Bitmap objects and overall process memory are different scopes.
Doze analysis adds light/deep idle state labels and transition timelines. Quick switching is worth further investigation, but just being "frequently switching" does not prove abnormal battery drain.
CPU PMU analysis adds counter deltas, event ratios, and available process ownership information, provided the trace recorded the required counters. Hardware events not captured won't appear after an upgrade; when ownership is insufficient, it cannot be forced onto a specific app.
Camera, rendering, and display differences
Camera analysis now more clearly measures observed frame beats and unifies SurfaceFlinger binding judgments. Buffer/Transaction analysis distinguishes frame production, transaction activity, and presentation evidence; WebView, React Native, browser compositing paths each have their own conditions.
This matters for the inference that "looks like render activity, so the frame must have been displayed." Production-side activity only supports observations at that stage; confirming display requires binding and presentation evidence. The product's rendering explanations are now maintained as teaching cards, verified together with the pipeline directory.
TraceDemo ran several rounds; what was fixed specifically
Problems found in testing often don't appear as "completely unable to run." The model may have delivered a report, but took detours: failing to read back evidence, calling discovery tools as Skills, guessing parameters wrongly, identity rejection reasons squeezed out by long results, or SQL using non-existent columns.
These issues directly affect whether an investigation proceeds smoothly, so we kept ledgers and targeted regression tests from different rounds. In the table, P1–P5 are five process fixes, F1–F6 are six diagnostic and invocation issues summarized after the fresh50 investigation.
Different batches used different code revisions and samples. The completion count in the figure is not diagnostic accuracy; targeted regression is not equivalent to rerunning the full batch.
| Record | Observation and result | What it can show |
|---|---|---|
| fixround88 | 88 synthetic samples recorded as complete | Exposed tool-usage issues during analysis; did not recompute every conclusion line-by-line |
| P1–P5 targeted regression | 9/9 deliveries completed; target error strings disappeared for corresponding cases | Still had 15 free SQL failures with recovery; cannot be written as all tools zero failures |
| unseen30 | Original batch: 29 successes, 1 failure; aggregated evidence: 27 original completions + 3 isolated replays | A concurrent asset modification caused dist and runtime assets to mismatch; original 29/1 ledger preserved |
| fresh50 | 49 batch records + 1 standalone smoke completion | Happened before F1–F6 fixes; fixes did not rerun all 50 cases |
| fresh50 fix validation | Camera, thermal naturally reran, plus controlled diagnostic probes | Validates corresponding fixes; does not represent overall benefit for all scenarios |
These data come from TraceDemo runner artifacts and SmartPerfetto's local verification records. Publicly reviewable release information is in the 1.19.0 Release; full traces and local sessions are not attached to this article.
A few concrete examples
Error messages must tell you what went wrong. In one case, the key reason for identity rejection was squeezed out of the result summary by a long parameter contract. Now the safe reason and next steps are prioritized. SQL logs can also give limited missing-table, missing-column, missing-function identifiers and query hashes for diagnosis, without outputting the full raw SQL.
The model's SQL priors can also become stale. sched.is_idle is a concrete example: the correct approach is to use thread.is_idle through a thread join. We added a core column quick-reference checked against the built-in schema, slice/thread join guidance, and window function guidance. In a camera singleton rerun, SQL failures went from 3 to 1, but the total query count differed, so a single sample isn't enough to prove a general percentage reduction.
Large-number timestamps need explicit units. The thermal case had an error at the second scale. Now second previews are derived only from values whose units are explicitly ns and can be precisely processed, preserving original cells and clock start. In targeted checks, 394361.352 s → 394406.092 s corresponds to 44.74 s. Another frequency unit label issue from that record remains unfixed and cannot be counted as fixed together.
When evidence is insufficient, plans must explain what's missing. Phase feedback lists missing calls, successfully completed calls, and failed calls with real tool-call IDs. The model can re-check or cite the failure to explain why forensics is impossible; this does not automatically turn unresolved investigation items into successes.
Semantic review also leaves boundaries: summing CPU time across multiple parallel threads does not directly prove end-to-end critical path; SurfaceFlinger going through HWC does not imply that all global GPU work comes from the target app. I want readers to see these problems exist, not just a string of green completions.
The final release package was verified separately
1.19.0's complete verify:pr passed, including 405 corpus expectations, 2013 SQL contract executions, and 6/6 scenario trace regressions.
Of the 2013, there are normal production paths, forced contexts, isolated probes, and exact UPID bindings; only some contain positive semantic assertions, so they cannot be treated as 2013 real-model cases. SQL coverage showed 0 skipped / 0 unavailable; other tests retain existing skips.
Delivery was also accepted separately: Windows/macOS/Linux final archive native smoke, npm Trusted Publishing and public install, Docker dual-architecture build.
The macOS package completed Developer ID signing, notarization, and stapling; npm was checked in an environment without credentials and with install scripts disabled for native SQLite and real-trace queries; Docker's version, latest, and SHA tags point to the same dual-architecture manifest.
Already using your own agent? Install Perfetto-Skills directly
Don't want to run SmartPerfetto's full UI and backend? That's fine. Perfetto-Skills is a standalone Agent Skill targeting agents with file and terminal capabilities, providing analysis workflows, SQL, evidence rules, and a deterministic runner.
| How you want to work | Better entry point |
|---|---|
| Open a trace, investigate in the UI, save sessions, export reports, do comparisons | SmartPerfetto |
| In existing Codex, Claude Code, or OpenCode, let the agent analyze local traces with the methodology | Perfetto-Skills |
It doesn't require SmartPerfetto backend, Provider runtime, UI, or MCP service. Public SQL and methodology assets are synced from pinned commits, with its own native code, independent real-trace fixtures, and full gates. This release pins to 1.19.0, with public repo commit 070053917, and full gate record of 514 tests, 1 skipped.
Per the repo's current README installation, run in your project directory:
npx [email protected] add Gracker/Perfetto-Skills \
--skill perfetto-performance-analysis \
-a codex -a claude-code -a opencode -y
Keep only the -a flags you use; add -g for user-level installation. Running scripts requires Python 3.11+; first-time use prepares a pinned version of the trace processor per the Skill's instructions. The skills CLI is a convenience ecosystem tool, not an installer required by the Agent Skills spec itself.
You can start with a question like:
Use perfetto-performance-analysis to analyze the target app's startup in this trace. First confirm the process instance and time window, then list key evidence, reasons that cannot be confirmed, and recommended data to collect.
SmartPerfetto removed its own embedded OpenCode execution engine; using Perfetto-Skills in standalone OpenCode remains a separate usage path. Also, this project is not a Google official Perfetto Skill: it provides its own domain workflows and executor; the official Skill is an independent upstream choice. See the Perfetto-Skills README for installation and usage details.
The same limitations apply here: SQL being executable does not equate to a causal conclusion being verified; having a local trace doesn't mean you can ignore the data scope sent to model services. Agent file permissions and Provider data policies are the user's responsibility.
Download and upgrade
The GitHub Release provides Windows x64, macOS arm64, and Linux x64 self-contained packages with bundled runtime. The npm CLI requires Node.js 24:
npm install -g @gracker/[email protected]
smp --version
smp doctor --format json
Without a configured Provider, doctor will indicate the AI runtime is not ready and that credentials need to be added. Docker can use w553000664/smartperfetto:1.19.0; latest has also been updated; it does not read the host's Claude Code login state.
This release did not backfill historical data. Old Providers are handled per existing migration rules; deprecated configurations that can't be mapped require re-entering a valid endpoint. PMU, heap objects, or presentation information not captured in past traces cannot be recovered by upgrading. The final version did not rerun full acceptance of all real Providers; the historical GLM/DeepSeek test scope in this article cannot be generalized to all models and cloud services.
This time I both record the new engine and capabilities, and the issues found in testing that are seemingly small but interrupt investigations. If you want the full analysis product, download SmartPerfetto; if you prefer to stay in your own agent working environment, try Perfetto-Skills.