v1.1 · free for individual developers

Catch the regression
before your users do.

Every launch of your app becomes a measured session, and the run that got heavier gets flagged.

Download for Windows See what it does

Windows 10 / 11 (64-bit) · ~30 MB · .NET 8

What the video shows

  1. An AI wrote the code, and the app launches slower: 3.5 s became 4.4 s, 22.7 % more, measured on two real runs.
  2. Nobody noticed: Task Manager only shows right now, while Ambih Monitor keeps every run.
  3. Every launch is recorded as a session: CPU, RAM, disk, network and GPU, per project.
  4. Past runs set your normal, and the heavier run is flagged as a regression: RAM went from 471.5 MB to 502.3 MB.
  5. ambih verify fails the CI build when a run goes over its budget.
  6. Ambih Monitor is a free download for Windows 10 and 11, about 30 MB, with no account needed.
Language-agnostic — it measures the process, so it works with
  • Electron
  • Tauri
  • .NET
  • Node.js
  • Python
  • Go
  • Rust
  • Java
  • PHP
  • Flutter

How it works

From folder to footprint in three steps.

Point it at a folder. It finds the stack and the command, then measures the whole app, child processes included.

  • Stack detected and launch command suggested
  • Optional CPU and RAM caps, unlimited by default
  • Every child process counted, not just the main one

What the video shows

  1. Pick your project’s folder: Ambih Monitor detects the stack, here Node.js and React.
  2. It suggests the launch command, here npm run dev.
  3. It runs your app under a Job Object, with optional CPU and RAM caps (unlimited by default).
  4. It measures the whole process tree, your app and every child process, and records it as a session.

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
  • ambih exec & ambih diff — one-shot benchmarks and run-to-run comparison
  • JSON output for agents, jq pipelines and CI dashboards

What the video shows

  1. An example CI run: checkout, install, build, then ambih exec records the build (peak 412 MB, CPU 38 %, 6.2 s).
  2. ambih verify checks it against a 512 MB memory budget: it passes, exit code 0.
  3. With the budget at 400 MB, the same build fails: 412 MB is over, exit code 1, and the pipeline stops.

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

What the video shows

  1. CPU, RAM, network and disk update live while your project runs.
  2. When RAM drifts above its baseline, a Drift alert lands on its card (Pro).
  3. The event is kept in the session’s spike history.

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)

What the video shows

  1. This session is compared with the runs before it: RAM 502.3 MB against 471.5 MB.
  2. The verdict is Regression: RAM +6.5 %, network +17 %, disk 22σ above; CPU stays below the floor.
  3. With five prior runs, the confidence is medium: 66 out of 100.

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)

What the video shows

  1. Pick any two runs.
  2. Memory improved: 502.3 MB to 469.4 MB, 6.8 % less. Network spikes regressed: 0 to 3.

What your app costs to run

The startup is measured on its own, so a slow start never skews the baseline. What is left is the app’s real footprint, on a user’s machine or a server.

  • Launch phase kept out of the baseline (Pro)
  • Steady-state CPU, RAM, network and disk for every run
  • GPU and VRAM, opt-in per project

What the video shows

  1. One run’s RAM: a peak while the app starts, then a steady level.
  2. Ambih Monitor keeps the launch phase apart, so the startup peak does not skew your baseline.
  3. What is left is the app’s real footprint: 536 MB steady, in this run.
  4. GPU and VRAM can be measured too; you turn them on per project.

See every screen

Download for Windows

Free: live monitoring and the last 5 sessions per project. Pro: unlimited history and the analysis above. See pricing

System requirements

Operating system

Windows 10 (1809+) or Windows 11, 64-bit

Runtime

.NET 8 Desktop Runtime (bundled in the installer)

Memory

4 GB RAM minimum, 8 GB recommended

Disk

~150 MB after install

Permissions

No admin rights required for normal use

Optional

Local git for the Git overview, Windows Terminal for “Open in terminal”

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

Download Ambih Monitor

Pick your platform. Windows is here today; macOS and Linux are next.

macOS

Universal · Apple Silicon + Intel

Coming soon
  • libproc resource sampler planned
  • posix_spawn rlimits for throttling
  • Native ARM & x64 builds

Linux

.deb · .rpm · AppImage

Coming soon
  • cgroups v2 for CPU / memory limits
  • procfs-based resource sampler
  • X11 & Wayland support

Using this? Other developers would find your experience useful. Write a review

Things people ask before they download.

What’s the difference between Free and Pro?
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 ».

Download for Windows

The other Ambih apps

While you are here.

Ambih Code Helper

See how a codebase fits together: what each file does, what depends on what, and where it touches a database or an API.

Windows 10 and 11 ·v0.1.0 ·~53 MB ·Free on one project

Download What it does

Windows will show an “Unknown publisher” warning the first time you run it. Choose More info, then Run anyway.

Ambih Central MD

Decisions, rules and rollbacks kept next to the code, for you and your AI assistant.

npm package ·Free on one machine

npm i -g @ambih/coding-agent-memory
Install guide What it does

Ambih Screen Recorder

Record your screen to a video file. No account, no watermark, no time limit.

In development

What it does