WonderPhi Autonomous Compute Industrial -- Commercial License
Publicly online since 2010 · U.S. patent applications since 2012 · inventions offered since 2014. The work of Christopher Gabriel Brown, independently documented.
WonderPhi Autonomous Compute Industrial -- Commercial License
Commercial-license edition of Autonomous Compute. Fleet-wide watcher deployment, priority support. Same three cooperating watchers, same SeDebugPrivilege escalation, commercial license.
© CRI-ONE. All rights reserved. Patents issued and pending. Unauthorized reproduction of the underlying designs is prohibited.
Extended catalog & full narrative — WonderPhi Autonomous Compute Industrial -- Commercial License
The extended dossier appended from the 2026-08-05 catalog snapshot. Prices in the body copy have been stripped; the live-store price on this page is the authoritative figure. Images have been omitted.
WonderPhi Autonomous for organizations — perpetual single-organization commercial license
Everything below is identical to the retail product. What's different: your license covers the entire buying organization (unlimited machines, VMs, containers, cloud instances) with no seat count, no annual renewal, no telemetry, no activation. Redistribution / SaaS / hosted-service exposure require a separate OEM arrangement.
Easy Setup — No Package Manager, No Account, No Cloud
One PowerShell line, no admin needed. No Python required on the target machine.
Set-ExecutionPolicy -Scope Process -ExecutionPolicy Bypass .\install.ps1
Copies the binary to %USERPROFILE%\bin, creates the inbox and outbox folders, and registers three scheduled tasks that auto-start on login. Done in about fifteen seconds.
WonderPhi Autonomous — the self-improving constitutional runtime
A three-agent runtime that quietly watches your machine, notices when you keep doing the same command by hand, and offers you a plan file the next time you would have started typing it. Same 10-commandment constitution as Compute. Never runs anything you did not approve.
Why this exists
WonderPhi Compute is a huge unlock, but you still have to know a job is parallelizable to write a plan file. Most operators don't — they just type the same command twelve times in a row.
Autonomous closes that loop. It watches your process list. When it sees the same tool launched five or more times in a ten-minute window, it writes a hypothesis file: "You did this by hand twelve times — here's a plan file that would run them all at once." It does not execute. It suggests, in writing, on disk. You accept by moving the plan into Compute's inbox.
What it is, in plain English
Think of three quiet helpers, each with one job:
- The observer. Watches which programs you launch. Notices patterns. Writes down suggestions. Does not run anything.
- The auto-planner. When you drop a bunch of similar files into a special folder, it writes a plan for them automatically and hands the plan to Compute. Fully hands-off — but only for the "bulk drop" case you opted into.
- The watcher. Sits on the same inbox as Compute. When a plan file appears, it runs it. Logs everything.
They never install themselves without your say-so. They never call home. They never touch a file you didn't put in their folder.
How you use it — three shapes
- Passive observation. The observer runs quietly. Every so often you get a
wpc-hypotheses/folder with a Markdown file: "You ranffmpeg17 times this week. Here's a plan that would have done it in one pass." Read it, decide. - Bulk-drop auto-mode. Copy 200 similar files into
wpc-auto/. The auto-planner recognizes the batch (5+ files of the same type), generates the right plan (PDF hash / image identify / log grep / SHA-256 / whatever), dispatches to the main watcher. You come back to finished work. - Direct dispatch. Same as Compute alone: drop a hand-written plan into
wpc-inbox/, watcher runs it. Autonomous doesn't get in the way.
Worked examples
Observer catches a pattern
You spent Tuesday afternoon running ffmpeg -i src.mov out.mp4 by hand on 34 different files. On Wednesday morning, wpc-hypotheses/2026-07-24-ffmpeg-batch.md contains:
# Hypothesis: parallelize repeated ffmpeg invocations Between 14:03 and 16:47 on 2026-07-23 you launched ffmpeg 34 times against different .mov files. This is a textbook batch job. Proposed plan (wpc-inbox/ffmpeg-batch-2026-07-24.wpc.txt): ffmpeg -i clip01.mov -c:v libx264 -crf 22 clip01.mp4 ffmpeg -i clip02.mov -c:v libx264 -crf 22 clip02.mp4 ... Expected speedup: ~14x on this 40-core box. Move the plan file to wpc-inbox/ to accept, or delete this hypothesis to ignore.
Auto-planner handles a bulk drop
You copy 200 PDFs into wpc-auto/. Within 15 seconds, the auto-planner recognizes the batch (5+ PDFs = 'PDF batch'), generates a hash-and-index plan, moves the plan to wpc-inbox/. Ten seconds later Compute has all 200 hashed and manifested.
Verified capabilities
Verified on the same dual Xeon Gold 6138T (40/80 cores) with an NVIDIA A10M as Compute:
- Observer overhead: ~0.1% CPU. Samples the process list once per minute. You will not notice it running.
- Auto-planner latency: a bulk drop of 200 similar files becomes a running plan in under 15 seconds.
- Hypothesis quality: tuned to a floor of 5 same-tool invocations in 10 minutes. Suggestions are actionable; you're not drowning in noise.
- Zero false starts: the observer never runs a plan on its own. Auto-planner only runs when you drop into the auto folder you opted into.
Every claim is testable on your own machine using the sample plans in the download.
Under the hood
Autonomous is three small executables that share Compute's constitution but each have one job. They never modify wpc.exe. The ten commandments and version-1.0.0 constitutional guarantee stay completely intact.
- wpc-watcher.exe — the inbox watcher. Runs whatever plan file appears. Injects live GPU env vars (
WPC_GPGPU,WPC_GPU_VRAM_FREE_MB,WPC_GPU_UTIL_PCT) into every task's environment so plans can branch on GPU availability. - wpc-autoplan.exe — the bulk-drop planner. Watches
wpc-auto/. Recognizes patterns (5+ same-type files) and emits the right plan. - wpc-observer.exe — the process-list observer. Samples every minute. When it sees repeated same-tool launches, writes a hypothesis
.md. Observes and suggests — never executes.
All three helpers use the same log-append and honest-exit-code guarantees the constitution enforces on Compute itself. Nothing is ever silently mangled.
What you need
- Windows 10 / 11. Native
.exe; the three helpers register as Scheduled Tasks that auto-start at logon. - WonderPhi Compute installed (or, easier, get the bundle). Autonomous is the loop-closer around Compute — it doesn't replace the runtime.
- No admin rights needed for install. Everything lands in
%USERPROFILE%\bin.
What's in the download
wpc-watcher.exe,wpc-autoplan.exe,wpc-observer.exe— the three helpersinstall.ps1— one-line installer, registers the Scheduled Tasksuninstall.ps1— removes the Scheduled Tasks cleanlyREADME.md— concise reference for humansLICENSE.txt— perpetual single-user license, personalized with your name and order number
Common questions
Q. Will it run something without asking me?
The observer never does. The auto-planner only runs when you drop files into wpc-auto/ — a folder that only exists if you asked for it. If neither has your consent, nothing runs on its own.
Q. Does it phone home?
No. Zero network access. Nothing about your workflow ever leaves your machine.
Q. Does it replace WonderPhi Compute?
No, it depends on Compute. It closes the loop around it — observation, auto-planning, watching. Compute is the runtime that actually runs plans.
Q. Can I turn off individual helpers?
Yes. Each is a separate Scheduled Task. Disable the observer from Task Scheduler and the observer stops running. Same for auto-planner and watcher.
Q. Where do hypothesis files go?
%USERPROFILE%\bin\wpc-hypotheses\. Read them, keep them, delete them — nothing acts on them until you move them into wpc-inbox/.
Glossary — every term used above, in plain English
- Observer / auto-planner / watcher
- The three cooperating helpers. Each does one job.
- Hypothesis file
- A Markdown suggestion the observer writes to disk. Never runs itself.
- Bulk drop
- You copy 5+ similar files into
wpc-auto/. The auto-planner recognizes the pattern and dispatches to Compute. - Scheduled Task
- Windows' built-in mechanism for programs that auto-start at login. Each Autonomous helper installs as one.
- Constitution / commandments
- The ten immutable rules baked into every WonderPhi binary. Verified at startup by SHA-256. Autonomous respects the same constitution as Compute.
- Telemetry
- Software calling home to report activity. Autonomous has none.
License & support — Industrial variant
Perpetual, non-exclusive, non-transferable Industrial license. Covers all machines, VMs, containers, and cloud instances operated by a single organization (the legal entity named on the purchase receipt plus wholly-owned subsidiaries). No seat count, no machine limit, no renewals, no activation, no telemetry.
Employees, contractors, and consultants under the organization's direction may operate the software solely for the licensed organization's benefit. Rights end when their engagement ends.
Not permitted without a separate arrangement: redistributing the software; hosting it publicly; embedding it in a product/SaaS/PaaS you sell to third parties; sublicensing.
Support: email chris@cri-one.com.
Every download's LICENSE.txt is personalized at checkout with your organization name, order number, and issue date. USA sales.