Ambih Monitor turns every launch of your apps, dev servers and scripts into a baselined session — CPU, memory, disk, network and GPU, per project — then flags the run that got heavier. Find the leak in your dev loop, not from a 2 a.m. alert.
Works with whatever stack you (or your AI) are shipping.
Electron
Tauri
.NET
Node.js
Python
Go
Rust
Java
PHP
Flutter
How it works
From folder to footprint in three steps.
01
Add your project
Point Ambih Monitor at a folder. It detects the stack, suggests a launch command, and offers a web-server profile for PHP projects.
02
Run it under a Job Object
Ambih Monitor launches your project with optional CPU / RAM caps and samples its whole process tree once a second.
03
Watch it evolve
Every launch is recorded. Compare today’s footprint with last week’s, spot the leak, and know exactly what your app needs to ship, on a user’s machine or a server.
From launch to launch
See what your app really costs to run.
Ambih Monitor turns every launch into data, so you ship leaner code, not just code that compiles.
History & baselines across every launch
Ambih Monitor records CPU, memory, disk, network and GPU for every run, then learns each project’s baseline, so you see the trend across launches, not just the last 60 seconds.
Catch leaks & regressions automatically
When memory creeps or CPU climbs above a project’s usual, Ambih Monitor flags it and rates the run Stable, Watch or Regression. Find it in your dev environment, not from a 2 a.m. alert.
The safety net for AI-generated code
AI writes code that works; rarely code that runs lean. Ambih Monitor catches the memory bloat and CPU debt your assistant didn’t think to optimize.
Know exactly what your app needs
See the real CPU, memory and GPU your app uses on actual hardware: the numbers behind a desktop app’s system requirements, or how small a server you can deploy to. Spec it from data, not guesswork.
Compare any two runs
Hand-pick two or more past runs and Ambih Monitor lays their CPU, memory, disk and network side by side, with a per-metric improving / regressing verdict. Answer “did my last change make it heavier?” in seconds.
Down to the GPU & VRAM
Opt in per project to track GPU utilization and dedicated / shared VRAM alongside CPU and memory: the missing half of the picture for games, ML workloads and GPU-accelerated apps.
Where live monitoring becomes performance analysis.
Free gives you live monitoring and a 5-session history per project. Pro adds the performance-analysis layer: anomaly detection, regression scoring, baseline health, and a session deep-dive that compares any run to the nine before it.
Spike & drift detection
Scaled-MAD spike scoring and a one-sided CUSUM drift detector flag the moment your app starts behaving differently. Severity-graded: only Warning and Critical ping the bell.
Regression verdict across launches
Robust z-score against the prior nine comparable sessions, with a Bonferroni guard so noise can’t flip the verdict. Stable, Watch or Regression: labelled, never hidden.
Baseline & health
Per-project median + scaled MAD baselines for CPU, RAM, network and disk. A weighted multi-factor score tells you whether this launch is normal evolution or a real change.
Session deep-dive
For any past run: memory growth banner, per-resource spike intervals, an ordered anomaly list with σ scores, and a "Compared to last 9" verdict that replays as if you opened it that day.
Project history with trend charts
Unlimited session history (Free keeps the most recent 5) with CPU, RAM and network trend lines, dashed median baselines, and chart-annotation dots for sessions with anomalies.
Launch-phase analysis
A launch segmenter separates startup transients from steady state, so a slow startup doesn’t contaminate your steady-state baseline, and a real startup regression shows up where you can see it.
Pro from $10/mo billed annually. No card needed to start on Free.
CLI · CI
Not just a monitor. Part of your pipeline.
Ambih ships a real command-line interface. Launch a project, benchmark a one-shot command, diff two runs — and gate CI on performance the same way you gate it on tests. When a build grows heavier than its baseline, the build fails.
ambih verify exits non-zero on regression — like eslint --max-warnings 0 for resource use
Budgets that fail the build: --max-memory, --max-cpu, --max-duration
JSON output for agents, jq pipelines and CI dashboards
ci · performance gate
$ ambih exec api "npm run build" ● recording session… peak 412 MB · CPU 38% · 6.2 s ✓ session saved$ ambih verify api --check no-anomalies --max-memory 512MB ✓ no-anomalies PASS ✓ max-memory PASS 412 MB < 512 MB → exit 0$ ambih verify api --max-memory 400MB ✗ max-memory FAIL 412 MB > 400 MB → exit 1 your CI step fails here
Inside the app
Monitor live. Analyze across every run.
Live monitoring with spike history
See CPU, RAM, network and disk update in real time while your project runs. When something deviates from the project’s typical behaviour, Pro flags it as Spike / Drift / Critical and keeps a per-session list of every event with σ scores and the values that triggered it.
CPU / RAM / Network / Disk live charts with min / avg / max
Per-tab "Spike history" with severity badges (Pro)
Anomaly alert pill on every metric card
Per-project baseline & health
Pick a project and see how today’s run compares to the median of recent runs by CPU, RAM, network and disk. A weighted, sign-aware score classifies the latest as Stable, Watch or Regression, with a confidence indicator based on how much history is in the corpus.
Median + scaled MAD baselines per metric (Pro)
Trend charts with dashed baseline reference line (Pro)
High-confidence regression verdict after 5+ sessions (Pro)
Session deep-dive: compared to last 9
Click any past session for a memory-growth banner, three pill tabs (Session avg / Current / Compared to last 9), per-resource spike intervals, and an intra-session trend chart for CPU / RAM / Network / Cores used. The comparison view replays the verdict as it would have looked when the session ended.
Memory growth banner with start → end delta (Pro)
Spike-interval cards: mean seconds between consecutive spikes (Pro)
Ordered anomaly list with σ score and metric label (Pro)
Compare any runs, side by side
Hand-pick two or more past runs and see per-resource averages, an oldest → latest trend, and a per-metric improving / regressing verdict. The fastest way to answer “did my last change make it heavier?”, without leaving the app.
Pick any 2+ sessions: averages for CPU / RAM / network / disk
Per-metric trend: improving, stable or regressing (Pro)
Side-by-side charts across the selected runs (Pro)
Tech-stack inspection & Git overview
Every project gets an at-a-glance card: detected stack with framework + dep count, Git branch with dirty/clean state, nested-project list inside monorepos, and one-click launchers for VS Code, your terminal and the file manager.
While you code in another window, the floating widget shows CPU, RAM, network up/down for the current project. Compact, retractable, and you can pop out the output terminal alongside it when you want it.
One window per project: auto-shows when the main app is hidden
Local git for the Git overview, Windows Terminal for “Open in terminal”
Why not just Task Manager?
Task Manager shows what’s running. Ambih Monitor shows what changed.
Built for the gap that Activity Monitor, htop and Task Manager leave behind: per-project history persisted across launches — and your app’s real footprint, with the launcher shell and build-tool noise stripped out.
Task Manager
Ambih Monitor
Per-project CPU & memory
Aggregates the full process tree
App’s real footprint — strips shell & dotnet run/build noise
History across launches
Compare runs side-by-side
Anomaly & regression detection
Hard CPU & RAM ceilings
Floating mini-monitor per project
Stack auto-detection
Get it
Download Ambih Monitor
Pick your platform. Windows is here today; macOS and Linux are next.
Free gives you the customized task manager: live CPU / RAM / disk / network / GPU charts, a project dashboard, the floating mini monitor, the gaming overlay, hard limits, stack auto-detection, and a rolling 5-session history per project. Pro adds the analytics layer: spike / drift / regression detection, baseline + health verdict, session deep-dive with "Compared to last 9", session comparison, trend charts, and unlimited history. See full comparison →
Do I need admin rights to install or run it?
No for everyday monitoring. Ambih Monitor installs into your user profile and samples processes you own: CPU, memory, disk, network, GPU and VRAM, throttling and the network inspector all work without elevation. A few extras do need admin: the live temperature / power sensors and the FPS counter in the gaming overlay. You can grant that from inside the app when you want them.
How is this different from Task Manager / htop / Activity Monitor?
Those tools show you the current state of every process. Ambih Monitor scopes the view to one project at a time, aggregates its whole process tree (wrapper + children), and persists the timeline so you can compare today’s run with yesterday’s, with statistical baselines on Pro.
How does anomaly detection actually work?
Spikes use scaled-MAD scoring against a rolling 60-sample baseline (3σ threshold). Memory drift uses a one-sided CUSUM detector with a Welford warm-up. Cross-session regression uses a robust z-score over comparable historical sessions with a Bonferroni cap. Every detector skips the launch-phase transient so steady-state baselines stay clean.
Will the throttling actually slow my dev server down?
Only if you set a cap and the project exceeds it. With no profile applied, Ambih Monitor adds no measurable overhead: the sampler runs at 1 Hz on a background thread and shares the same Job Object the OS would create anyway.
Can Ambih monitor a desktop app, not just a dev server?
Yes, it’s built for both. Point Ambih Monitor at any executable or project folder: an Electron, Avalonia, .NET, Python or game build, not only a npm run dev server. It aggregates the whole process tree, so a packaged desktop app and a running dev server are measured the same way.
Does it track GPU and VRAM?
Yes. Opt in per project and Ambih Monitor charts GPU utilization and dedicated / shared VRAM right next to CPU and memory, and folds them into the baseline and regression analysis. Vendor-agnostic across NVIDIA, AMD and Intel, with no NVML or extra drivers to install.
Is there a gaming-style overlay with FPS?
Yes. A system-wide, always-on-top overlay shows live CPU, RAM, GPU and FPS while a game or app runs, plus a System Information page for the full hardware spec. The FPS counter and live temperature / power readouts need the app running as admin.
Can I drive it from the terminal or an AI agent?
Yes. The bundled ambih CLI launches, monitors, compares and queries your projects from any terminal, with --json output and a verify command that returns CI-style exit codes, handy for agent and autonomous-loop workflows.
How do I know how much RAM and CPU my app actually needs?
Run it under Ambih Monitor for a few typical sessions. The baseline shows the median and peak CPU, memory, disk and network your app really uses: the numbers behind a desktop app’s system requirements, or for right-sizing a server or container before you deploy, instead of guessing and overpaying for headroom.
My antivirus or SmartScreen flagged the installer: is it safe?
Yes. The Windows installer isn’t code-signed yet, so SmartScreen may show an “unknown publisher” notice and some antivirus engines flag it heuristically. Here’s why that happens and how to verify the download →.
Is there a macOS or Linux build?
Windows is the live download today. The macOS and Linux backends are already built (sampling, throttling, toolchain detection and launchers all run), so what’s left is packaging and signing (notarization on macOS) before they ship. Use the Notify Me link on the download cards to hear when they’re available.
Know what your app needs before you ship it.
By the time you ship a desktop release or a deploy, you'll already know what your app really consumes. No more guessing at system requirements, no overspending on server headroom « just in case ».
