Shayne WinterAI Systems Lab

HomeAI Systems LabAgentOps

Platform lineage / bounded Windows operations

Integrated into Pegasus Cortex

Give AI tools a safe, repeatable way to work on Windows.

What began as Pegasus AgentOps is now part of Pegasus Cortex. It gives AI-assisted workflows a defined list of approved local actions, clear limits, useful records, understandable failures, and a recovery path.

  • Implemented
  • Tested
  • Packaged
  • Installed
  • Live-verified
Platform: .NET 10 · Windows x64Evidence scope: One developer workstationRole: Discovery, requirements, authority design, failure reproduction, acceptance

The problem

AI agents needed useful local tools without unrestricted command access.

Repeated command construction created friction, inconsistent error reporting, and unclear authority boundaries. The meaningful problem was not merely command execution: it was how to offer a bounded catalog that could be called consistently, audited durably, recovered safely, and exercised from both agent and product-local workflows.

Design principles

Useful automation without turning an AI agent into an administrator.

  • Operations are explicit and structured rather than assembled as arbitrary commands.
  • Ordinary user work and protected machine changes remain visibly separated.
  • Filesystem and process work is bounded, cancellable, and designed to fail safely.
  • Installation, repair, diagnostics, and recovery are treated as part of the product rather than left to manual cleanup.

What it enables

Repeatable local work that the responsible person can still understand.

Consistent operationsAgents and products can request the same approved capability without inventing a new command each time.
Visible controlThe system makes it clear when work is ordinary user activity and when it crosses into protected machine changes.
Results that can be reviewedEach action leaves useful status and evidence that can be diagnosed, retried, or reviewed after the terminal session is gone.
Repair and recoveryInstallation, repair, and recovery are treated as part of the product rather than cleanup work left for later.

This public view focuses on the operating capability, product decisions, and engineering judgment while keeping implementation-sensitive transport, identity, service, path, and authorization details private.

What PAO can do

One safe way for AI tools to inspect, build, package, run, and repair Windows software.

PAO offers a catalog of specific operations instead of accepting any command an agent invents. That keeps common engineering work repeatable and gives each action a clear purpose and limit.

Files and sourceRead, search, compare, edit, copy, move, hash, compress, and inspect files through defined operations.
Build and source controlInspect Git state and run the standard .NET restore, build, test, package, and publish steps.
Running systemsUse approved PowerShell scripts and tools, inspect processes and listeners, and keep longer work available for review.
Windows installersCheck, validate, and build admitted NSIS installer projects through repeatable steps.
Windows interface checksUse AutoItX to find and operate windows and controls for focused acceptance testing.
Reusable extensionsAdd approved tools and repeatable multi-step recipes without opening unrestricted command access.

Technology credits

PAO provides the integration contract; these projects provide important underlying capabilities.

  • NSIS supplies the Windows installer compiler and Modern UI foundation used by the bounded installer adapter.
  • AutoIt and AutoItX supply the Windows UI automation library used for bounded application interaction and visual acceptance support.
  • 7-Zip supplies archive inspection, validation, and extraction capabilities reached through the registered adapter.
  • PowerShell, Git, and .NET provide the scripting, source-control, and build toolchains wrapped by PAO's typed operations.

What Shayne owned

The operation contract and acceptance boundary.

Problem discoveryIdentified recurring agent friction and mapped where shell-oriented behavior created unusable or unsafe boundaries.
Requirements and usabilityDefined typed schemas, mapped-path behavior, authorization expectations, installer/PATH behavior, and migration outcomes.
Authority decisionsRequired explicit user-versus-System separation and recoverable security-sensitive lifecycle behavior.
AcceptanceReproduced failures and accepted results across executable, service, MCP, installer, repair, and live runtime evidence.

AI role

Specialist implementation under human technical direction.

AI agents contributed implementation, testing, diagnosis, and review work within bounded modules. Shayne retained the problem definition, schema and usability requirements, authority decisions, architecture tradeoffs, correction of false assumptions, and final acceptance. The public ownership model distinguishes Shayne's technical direction and acceptance from the implementation work performed by specialist agents.

Verification

Source, focused tests, executable behavior, installation, and repair.

Focused module suitesCore operation, lifecycle, and failure-path coverage.
Service harnessAuthentication, identity, and service-boundary checks.
Clean release checkpointBuild and packaging completed cleanly.
Install + repairReal initial installation and same-version repair on one workstation.

A controlled repair exercise verified that the installed system could recover from deliberately introduced lifecycle damage. Together, these checks establish an installed, single-workstation alpha and its recovery behavior.

Result & next stage

An installed Windows alpha with tested repair behavior.

The result is an implemented and tested self-contained Windows x64 alpha that was packaged, installed, and live-verified on one developer workstation. The next validation stage expands compatibility and lifecycle testing across additional Windows systems and operating conditions.

Current evidence covers one developer workstation, focused test lanes, installation, repair, and real local operation. The next stage is broader Windows compatibility and lifecycle coverage.
Next AI Systems Lab case studyNeural Commander