How the sidebar reads
Four home rows with no heading, then three collapsible groups named by the question each answers.
The group holding the page you are on is open and the others are closed, each with one line saying whether it wants you. A badge is written only when it asks for an action, so Reviews, Crashes and Memory carry one and nothing else does. The workspace pages (Projects, Team, Usage, Affiliates and workspace settings) are in the project switcher menu at the top.
Three rules hold everywhere: a number is real or absent (
-- means no value has arrived, which is not the same as zero), every read fails on its own and says what survived, and Orbit is read only outward.
Overview
What changed around one project since you last looked. Eight health tiles, each a link to the page that produced its number: crash free sessions, crash groups, hang rate, reviews to decide, latest build, latest test run, compliance score and release state. Under them, Needs you (the decisions open on this project, each a link to the thing that needs deciding) and Activity (what happened anyway). All of it comes from one call, so if it fails the page shows the failure instead of a mix of stale and missing numbers.Insights
The same project over a window of 7, 30 or 90 days. Trend charts (new and resolved crash groups per day, sessions, hang rate, median build wall clock, test pass rate, merge confidence, compliance score), five Top lists (crash groups by report count, slowest files to compile, worst hangs, noisiest telemetry issues, and the review finding categories a human dismissed most), and a per-version table of crash free sessions, hang rate, sessions and adoption. A day with nothing in it is a gap in the line, not a zero. Read only, and it costs no credits.Reviews
The decision queue for pull requests the reviewer read. Three zones: Needs your decision, The loop is working, and Handled for you. A card carries its merge confidence gauge, the severity dots of its open findings, the specs of the verify run the pull request produced, its pre-merge checks and its effort chip. One review opens the walkthrough, the pre-merge checks, the change stack with each layer’s blast radius, and the findings, each expandable to its body, its suggested patch and the evidence it rests on. A finding can be dismissed as a learning, accepted, sent back to the agent, or fixed by applying its suggestion. Both dismiss and accept require a reason, and the reason is what stops the same note being raised twice. Learnings is where those reasons become rules the next review reads. You can also teach one by hand, as a sentence, optionally scoped to a path glob. Orbit writes four things into the pull request through its GitHub App, each with its own switch: a check run, one summary comment edited in place for the pull request’s whole life, inline comments on findings above a severity floor, and GitHub suggestion blocks where a fix is a contained replacement. A merge gate is off by default and is the only thing in Orbit that can block a merge. Reviewing itself never pushes: Apply suggestion is the one write to a branch, and a person clicks it. Reviews cost credits and price themselves first.Agent runs
Every agent session and verification the Parsaa app synced to this project, newest first, with the evidence trail behind it: the steps it took, how long each ran and what it left behind. Runs are not started here. They happen in the Parsaa app, which debits the credits for them, and then syncs the record. Syncing costs nothing and nothing on this page spends a credit.Verify
Every spec the Parsaa app replays against the project, with its latest verdict and the last ten runs behind it. Specs are written and replayed in the app; Orbit keeps the verdicts, which is what makes a check that only passes some of the time impossible to hide. A flaky mark means the last ten runs hold both a pass and a failure, which is an observation about the verdicts and not a claim about the cause. Each row’s history strip opens the run behind any verdict, so a flip is one click from its evidence.Screen map
Every screen the Parsaa app reached, wired by the navigation it found between them, plus the screenshots it captured per app version and device. The map is the app’s; the console reads it back, and syncing costs nothing. A screen the app mapped but never captured carries a structure only pill and offers Ask for a re-capture, which the app picks up on its next verify run. Heatmaps lay the last 7 days of taps over a screen’s newest capture, in two colours: accent for taps, warning yellow for dead taps, a tap the app did not answer within one second. Rage taps (three or more on the same view within one second) are counted beside them. The grid is normalised on the device’s own coordinate space rather than on pixels, so the same tap on an iPhone SE and an iPad lands in the same square, and it is re-folded nightly. Taps need thetaps surface on; dead and rage taps need nothing else at all.
Visual diff compares two captures of one screen on pixels, and says where they differ rather than why. A jpeg against a lossless png is refused rather than reporting compression noise as a screen change.
Telemetry
What the app reports from the field, in eight tabs. Everything here needs something reporting with this project’s SDK key.- Fleet: every device model and OS version reporting, with the app versions each is running. No device is identified. It is also where Request upload and Watch live reach one installation.
- Sessions: every session the SDK sent, each opening in the wireframe replay with its event timeline beside it. A network row that carried bodies opens them below itself, badged “captured on request”.
- Issues: events grouped by kind, name and top frame or masked message, so the same bug counts once however many times it fires.
- Alerts: one metric, one comparison, one threshold, one window, evaluated on a schedule. Channels are in-app or a signed webhook, and what fired is a row to read afterwards rather than a notification that came and went.
- Workflows: the rules devices run against their own ring buffer.
- Live tail: every event the project ingests as it lands, filtered server side. Three tails per project, 30 minutes each. It runs on your own session, never a project token.
- Users: everyone the app identified through
Capture.setUser, folded across their sessions. The hash is your app’s; Orbit never receives an identifier it could resolve to a person. - Vitals: MetricKit cards per metric, with percentiles read from the stored buckets, and the diagnostics behind them.
Performance
The deep local analysis of one Instruments recording: what held the main thread, which symbol spent the time, and which windows froze. A.trace is hundreds of megabytes, so the CLI uploads it and the workspace’s Mac runner parses it, because only xctrace can open one. Five tabs: Flame (symbols by self time), Hangs (every window over Apple’s 250 ms floor), Threads, Caveats (what this recording does not say, written while reading the trace), and AI. A debug recording says every number on it is an upper bound, because Main Thread Checker and the view debugger each inflate main thread cost.
Crashes
Apple.ips reports, parsed, symbolicated against the dSYMs on file and grouped by signature, so one group is one defect. They arrive two ways: dropped into the browser, or pulled from TestFlight every 30 minutes with an App Store Connect key. A group carries the symbolicated stack with the faulting thread marked, the device, OS and version spreads, the individual reports, the telemetry breadcrumbs leading into the crash, and an optional AI diagnosis with a confidence gauge, the root cause, the claims it rests on with the frames for each, and a suggested fix. Ingestion is free; only the diagnosis spends.
Tests
Every.xcresult bundle uploaded, through the CLI, which is the only door. The suites, the failures with their assertion verbatim and an expected-versus-actual diff where the failure is a comparison, the attachments a failing case captured, the flaky cases (a case that changes verdict without the code changing), and line coverage by target. Create issue opens a GitHub issue for one case, quoting the bundle rather than reading it, so it spends nothing.
Build
Everyxcodebuild uploaded, read back two ways: where the minutes went, target by target and file by file, and where the bytes went once the linker wrote them down. The Timeline tab needs the .xcactivitylog; the Size tab also needs a link map, built with LD_GENERATE_MAP_FILE=YES and attached to the build the log created. Parsing a build costs no credits.
Release
Where the app stands with Apple, read through the same App Store Connect key that brings TestFlight crashes in, refreshed every 30 minutes. The version in review with its timeline, the phased rollout percentage and Apple’s seven day schedule, TestFlight builds and tester feedback, the written store reviews with their ratings, and an AI review themes analysis where each theme carries a verbatim quote so it can be checked rather than believed. Orbit reads App Store Connect and never writes to it.Compliance
What App Review will look at, read from the archive before you submit. The scan runs offline on your machine (orbit compliance scan <path.xcarchive> --upload) and only the report is uploaded, never the archive. It checks required reason APIs against the privacy manifest, third party SDK manifests and signatures, the entitlements that changed, and a rule-based App Review checklist, and scores out of 100. A required reason API with no declared reason is blocking: it is rejected by the automated check before a human reviewer opens the app.
Memory
The project’s durable knowledge: decisions, conventions, gotchas, how-tos and the instructions every agent must follow. People and agents read and write the same rows through three doors, this console, the REST API and MCP, and the compiled instruction set is whatAGENTS.md and CLAUDE.md become. Five tabs: All (hybrid search plus filters), Curation (open collisions, recent writes from agents, drafts awaiting approval), Usage (coldest, never accessed, most used, stale), Instructions (the compiled bundle, with import and export) and Graph. Reads are free; only an AI merge, summary or contradiction classification spends.
Devices
The managed device farm: boot a build on a simulator, drive it yourself or hand the session to the agent. It is a coming soon surface, with every control disabled and carrying its reason. The fleet catalogue that used to live here moved to Telemetry’s Fleet tab.Settings
A route family,/settings/<scope>/<section>, with three scopes and a searchable rail.
Most panels are admin or owner only. Where a member cannot write, the panel says so and points at the Team page rather than showing a refusal. Plan stays readable by everyone, because what the workspace is paying for is not a secret from the people in it.