Early access pricing ends soon — Free tier available now. No credit card required. Start Free →
Deployment reliability engine for Intune · Early access

Reinstall Loops?|
Fix Intune Deployments Before They Break.

Automatically handle detection, upgrades, and install logic — so your deployments work the first time, at scale.

No reinstall loops · No silent failures · No downgrade issues
✦ Try pkgprobe Free See How It Works →
pkgprobe — product walkthrough 2:47
app.pkgprobe.io · trace · Slack-4.38.125.exe
InstallerSlack-4.38.125.exe
Silent Args/S /v/qn ALLUSERS=1
Confidence87% · VERIFIED
Intune✓ Ready to package
See pkgprobe extract silent args
from a real EXE in under 10 minutes
★★★★★
Took me 3 hours to figure out flags for one EXE. pkgprobe had it in under 10 minutes.
Endpoint Admin · NHS Trust
★★★★★
Detection rules that actually work. First time we've shipped an Intune package without a rework cycle.
SCCM Engineer · Financial Services
MSI · EXE · MSIX
All installer formats supported
~10 min
vs. hours of manual testing
0 Guesses
Commands backed by real trace data
Open-Core CLI
Available on PyPI
The Problem

Your deployments are breaking in ways you can't see coming.

It's not just missing flags. It's detection logic that lies, version conflicts that corrupt environments, and failures that only show up on production endpoints.

❌
Detection says "not installed" — forever
Your detection rule doesn't account for the installed version. Intune sees "not installed," redeploys, and loops. 400 endpoints. Endlessly.
❌
Works in test → breaks on 400 endpoints
A newer version is already installed. Your package runs, downgrades it silently, and breaks dependencies. No error. No log. Just a broken environment.
❌
Exit code 0. Install failed.
The script exits clean. Intune marks it successful. The app isn't there. You find out when users call the helpdesk — not when it happens.
How many times has an app deployed fine in test — then broken on 400 endpoints with no trace, no reason, and no fast fix? Most endpoint teams are still debugging this manually. Every app costs hours. Version conflicts cost outages.
How It Works

From installer to deployment-ready in minutes.

pkgprobe runs your Windows installer in an isolated VM, captures every system change with ProcMon, and generates a verified silent install command and Intune-ready package — with evidence, not guesswork.

Step 01
🔬
Trace
Run the installer inside an isolated VM snapshot. pkgprobe captures every file, registry, service, and task operation in real time.
  • VMware-backed isolation
  • ProcMon-level capture
  • Clean snapshot every run
Step 02
⚡
Analyze
The diff engine parses the trace and extracts a structured change summary — with confidence-scored detection candidates.
  • Silent arg extraction
  • File + registry footprint
  • Service + task detection
Step 03
✅
Verify
Get a confidence-scored InstallPlan and Verified Manifest. pkgprobe tells you if the package is ready — and exactly why if it isn't.
  • Explicit pass / fail reasons
  • Actionable failure diagnosis
  • Intune eligibility check
Intune Packaging

Generate .intunewin packages — only when they're actually safe to deploy.

pkgprobe verifies deployment-readiness before producing the artifact. That includes version detection, upgrade-path safety, and downgrade prevention — not just silent args.

verified_manifest.json ✓ VERIFIED
"silent_args": "/S /v/qn ALLUSERS=1", "verified": true, "version_aware": true, "upgrade_safe": true, "detection_candidates": [{   "type": "registry_key",   "confidence": 0.92 }], "verification_errors": []
🔒

Gated by verification

pkgprobe refuses to produce a .intunewin unless the manifest passes. High-confidence detection anchors required — no exceptions by default.

📦

Scripts from evidence

install.ps1 and detect.ps1 are generated from trace data — not templates. Detection logic references the actual anchors pkgprobe found.

🔢

Version-aware detection

pkgprobe ensures installs only run when needed — preventing reinstall loops, blocking downgrades, and handling upgrade paths automatically.

☁️

Local CLI or cloud API

Run fully on-prem with pkgprobe-trace, or use the API to get an artifact back without managing VMware yourself.

Why Deployments Fail

The failure modes that cost you the most — and how pkgprobe fixes them.

Silent flags are just the start. The deployments that hurt your environment most are the ones that fail invisibly, corrupt versions, or loop forever.

Without pkgprobe
❌
Detection says "not installed" → reinstall loop

Detection rule ignores the installed version. Intune keeps redeploying. Users see repeated installs. Helpdesk gets the calls.

❌
Newer version already installed → gets downgraded

Your package runs against a newer version already on disk. The installer downgrades it silently. Dependencies break. No warning.

❌
MSI upgrade fails silently mid-rollout

The upgrade code doesn't match. MSI skips installation without error. Intune marks it successful. Half your fleet is still on the old version.

❌
Script exits 0 — but the install failed

The wrapper script returns success. The actual install hit a prompt, a missing dependency, or a locked file. You find out from users.

With pkgprobe
✅
Version-aware detection

Detection rules include version data extracted from the trace. Intune only redeploys when it actually should — no loops, no noise.

✅
Upgrade-safe install orchestration

pkgprobe detects what's already installed and generates logic to skip, upgrade, or uninstall-first appropriately. No manual version checks.

✅
Uninstall-before-install logic

When an in-place upgrade isn't safe, pkgprobe generates uninstall-first sequences backed by trace evidence — not assumptions.

✅
Exit code handling baked in

Generated scripts validate real installation outcomes — not just process exit codes. If the app isn't there, it's a failure. Full stop.

Are We a Good Fit?

Honest answers before you commit to anything.

Every question here either puts your mind at ease — or tells you clearly if pkgprobe isn't right for your environment. Either outcome saves you time.

What installer types does pkgprobe support? +
pkgprobe handles MSI, EXE, and MSIX installers. For EXEs — which are the hardest because they don't advertise their flags — pkgprobe traces the actual installer in an isolated VM and extracts the working silent arguments directly from what the installer does, not from a database of guesses.
How is this different from just Googling silent switch flags? +
Google gives you community guesses, often outdated or version-specific. pkgprobe runs your actual installer in a clean VM snapshot, captures every file, registry, and service operation via ProcMon, and produces the exact flags that worked — for that version, on that day. You get a confidence score and a verified manifest, not a forum post from 2019.
What if pkgprobe can't extract flags for one of my installers? +
It happens — some installers are genuinely difficult. When a trace fails or confidence is too low to verify, pkgprobe tells you exactly why: which detection candidates were found, where the ambiguity is, and what you can do about it. You're never left with a silent failure and no clue. On the Free tier, that feedback alone is often worth the run — it tells you what you're dealing with before you waste hours on it manually.
Can I cancel or switch plans if it's not working for us? +
Yes — monthly plans can be cancelled any time, no questions asked. If you're on annual and hit a genuine issue, reach out and we'll work it out. We'd rather you have a good experience than be locked into something that doesn't fit. And the Free tier exists precisely so you can validate pkgprobe on real apps from your environment before spending anything.
Will it work with our existing Intune / SCCM setup? +
Yes. pkgprobe outputs standard .intunewin packages, install.ps1 and detect.ps1 scripts, and a structured JSON manifest that maps to Intune's Win32 app format. For SCCM, the same scripts and detection logic work as-is. Enterprise plans include direct SCCM + Intune integration workflows.
Do I need to manage a VM myself? +
No. The cloud API handles all of that — you upload the installer, pkgprobe runs it in an isolated VM, and returns the result. If you prefer on-prem, the open source pkgprobe-trace CLI lets you run traces against your own VMware environment. Both give you the same verified output.
Does pkgprobe work on installers that require user interaction to complete? +
This is actually one of the problems pkgprobe solves. Many EXEs fail silently in unattended deployments because they're waiting for a user prompt nobody answers. pkgprobe traces the installer's behaviour in the VM and flags interactive prompts in the failure report — so you know before you ship, not after 400 endpoints stall. Handling those edge cases is where the verified manifest earns its keep.
Is the installer uploaded to your servers? Is that safe? +
Installers are uploaded over TLS to an isolated trace environment. They're run in a clean, sandboxed VM snapshot and discarded after the trace completes. No installer data is retained beyond the session. For organizations with strict data handling requirements, the pkgprobe-trace CLI lets you run everything entirely on-prem — nothing leaves your network.
What does "verified manifest" actually mean? +
A verified manifest is pkgprobe's confirmation that the package passed all checks before being considered deployment-ready. That means: silent args extracted and confirmed working, detection rule candidates identified with confidence scores above threshold, and no verification errors. pkgprobe won't produce a .intunewin unless the manifest passes — no guessing, no hoping it works in production.
How many apps can I run per month on the Free tier? +
The Free tier includes 5 trace runs per month — enough to evaluate pkgprobe on real apps from your environment and validate the workflow before committing. The Team plan removes that ceiling for production use. You can upgrade at any time; there's no credit card required to get started.
Do you track every version of an installer, or just the latest? +
Every trace is run against the exact installer you upload — not a cached version, not a generic profile for that app. This matters because silent flags often change between versions, and a flag that worked on v4.1 may silently fail on v4.2. pkgprobe generates a fresh verified manifest for every run, so your packaging stays accurate as software updates.
What if we already have a packaging workflow — does pkgprobe replace it or fit alongside it? +
It fits alongside. pkgprobe handles the part of the workflow that's currently manual and error-prone — figuring out what flags work and verifying detection rules. Your existing approval process, documentation standards, and deployment pipeline stay the same. You just stop spending hours per app on the research and testing step. Most teams run pkgprobe as a front-end to whatever they're already using for deployment.
Pricing

Stop wasting hours on packaging. Deploy with confidence.

Automate Intune/SCCM packaging, eliminate trial-and-error installs, and standardize deployments across your environment.

→ If pkgprobe saves just 1–2 hours per app, it pays for itself almost immediately.

Built for real IT workflows
Save 1–4+ hours per package
Reduce failed deployments and rework
Eliminate guesswork with verified install commands
Improve auditability and consistency

→ Most teams recover the cost in their first 1–2 deployments

Free
$0 / mo
Test it on real apps. No risk.
Start exploring before you commit. No credit card required.
  • ✓ 5 trace runs included
  • ✓ Generate install commands from real installers
  • ✓ CLI access (open source)
  • ✓ Validate workflows before scaling
  • ✓ Community / email support
  • — Verified manifests + confidence scoring
  • — Failure diagnostics
  • — .intunewin packaging
Start Free
Most Popular
Team
$129 Annual
$114 / mo
or $129 / mo billed monthly
Stop guessing. Ship reliable packages faster.
Most teams recover the cost in 1–2 deployments.
  • ✓ Prevent failed deployments that impact hundreds of endpoints
  • ✓ Process your full packaging workload without bottlenecks
  • ✓ Shared workspace for team collaboration
  • ✓ Standardized outputs across engineers
  • ✓ See exactly why installs fail — no more guesswork
  • ✓ Verified manifests with confidence scoring
  • ✓ Generate ready-to-deploy .intunewin packages
  • ✓ Audit-ready logs and history
  • ✓ Priority support
Start Team Plan Book a Free Demo →
Enterprise
Custom
For teams that need control, compliance, and scale.
Custom onboarding, private deployment, and SLA-backed support.
  • ✓ Custom throughput for large environments
  • ✓ Everything in Team
  • ✓ SSO + advanced access controls
  • ✓ On-prem / private deployment options
  • ✓ Compliance-ready reporting and controls
  • ✓ SCCM + Intune integration workflows
  • ✓ SLA-backed support + dedicated onboarding
See If You Qualify → Contact Sales
No credit card required for Free tier
Annual price shown — save 12% vs monthly
Cancel anytime on monthly plans
Annual invoicing and PO support available

Not sure which plan fits?

We'll map pkgprobe to your environment, app volume, and tooling — and show exactly where you'll save time.

Book a Free Demo Start Free →
Free Demo

See how much time your team is losing — and how to fix it.

We'll walk through your actual packaging workflow and show where pkgprobe eliminates manual work, reduces failures, and speeds up deployments.

What you'll get

  • 🎯 A live walkthrough using your tooling (Intune, SCCM, or hybrid)
  • ⏱ A realistic estimate of hours saved based on your app volume
  • 🔍 Identification of bottlenecks in your current packaging process
  • 📐 A standardized, repeatable packaging workflow
  • 🛡 Guidance on compliance, auditability, and rollout safety
  • 📋 A recommended plan tailored to your environment

Who this is for

Endpoint Administrators SCCM / Intune Engineers IT Operations Managers 500–5000+ endpoints
Prefer to explore first? Start Free and book a demo when you're ready.
See if pkgprobe is right for your environment

We keep demo sessions small so we can personalize each one. Tell us about your environment and we'll confirm a time.

Is this just a sales call? +
No. We use the 30 minutes to map your actual packaging workflow and show you specifically where pkgprobe saves time in your environment. You'll leave with a realistic hours-saved estimate and a clear picture of whether it fits — even if you don't end up buying.
What if our environment is too niche or complex? +
That's exactly the kind of thing we want to know upfront. If pkgprobe isn't the right fit, we'll tell you straight — we'd rather say that now than have you find out after signing up. Fill in your biggest challenge above and we'll come prepared with a specific answer.
30-minute focused session
No obligation
Personalized to your environment
You'll leave with actionable improvements

Stop losing hours to
installer flags you can't find.

pkgprobe extracts the exact silent args that work — from your actual installer, in a real VM, in under 10 minutes. Free to start.

✦ Start Free — No Credit Card See If It Fits Your Environment →