Skip to Content

PMIVerse Multi-Agent Harness (What it is)

Making AI Software Development Safer, More Controlled and More Trustworthy

Making AI Software Development Safer, More Controlled and More Trustworthy

Artificial intelligence is changing software development very quickly.

AI tools can already help developers understand large codebases, suggest changes, write code, run tests, and solve increasingly complex engineering problems.

The next step is already beginning:

AI systems will not only assist developers — they will increasingly perform complete engineering tasks on their behalf.

That creates enormous potential.

It also creates a new problem.

If an AI system is allowed to work independently inside a real software-development environment, how do we make sure that it:

  • works only on the project it was assigned;
  • changes only what it is allowed to change;
  • does not accidentally repeat an operation;
  • does not interfere with the work of another AI agent;
  • can recover safely if something goes wrong;
  • leaves a reliable record of what actually happened;
  • remains under human and organizational control?

The PMIVerse Multi-Agent Harness is being developed to solve that problem.

It is not another AI model.

It is the control system around AI workers.

The Basic Idea

PMIVerse is based on a simple principle:

An AI system should be powerful, but it should not decide its own authority.

An AI agent may be capable of writing excellent code.

That does not mean it should automatically be allowed to modify every repository, run every command, delete files, or decide what should happen after a failure.

PMIVerse creates a controlled environment between the AI and the software it is working on.

The AI can focus on solving the engineering problem.

PMIVerse focuses on making sure the work happens within clearly defined boundaries.

Why This Matters

Today, most AI coding tools are still used interactively.

A developer opens a tool, gives it instructions, watches what it does, and intervenes when necessary.

That approach works while humans remain closely involved.

But as AI systems become more capable, companies will want to delegate larger tasks.

For example:

Investigate this problem.

Find which parts of the software are affected.

Make the required changes.

Run the tests.

Have another AI review the result.

Report back when the work is complete.

This is where the challenge changes.

The question is no longer only:

Can the AI write the code?

It becomes:

Can we safely allow the AI to perform the work?

PMIVerse is being built for that second question.

From One AI Assistant to a Team of AI Workers

The long-term future of software development is likely to involve more than one AI working on a task.

One AI may investigate a problem.

Another may make the changes.

Another may review them.

Another may test the result.

These systems may work at the same time and across several software projects.

PMIVerse provides the coordination layer around them.

Its role is to make sure that every worker has a clearly defined responsibility and does not silently take control of work that belongs to somebody else.

This creates the foundation for a future engineering environment where several AI workers can collaborate while still remaining under human control.

Humans Keep Control

PMIVerse deliberately separates the decision to approve an action from the system that performs it.

The system can check whether an action has been approved.

It can make sure that the approval applies to the correct work.

It can record when that approval was used.

But it does not create its own approvals.

This is important.

It means that organizations can decide for themselves:

  • who is allowed to approve AI work;
  • which actions require approval;
  • which actions may require two people;
  • how approval rights are revoked;
  • how important actions are audited.

The AI execution system does not become its own authority.

Designed for Failure, Not Only Success

Reliable automation is not defined by what happens when everything works.

It is defined by what happens when something goes wrong.

A computer process can crash.

A connection can disappear.

A server can restart.

An AI agent can stop halfway through a task.

One of the dangerous responses in such situations is simply to repeat the operation.

The original action may already have happened.

Repeating it may make things worse.

PMIVerse is deliberately conservative.

If the system knows that an operation completed, it can return the existing result.

If it knows that the operation never started, it may safely continue.

But if the result is uncertain, PMIVerse keeps it uncertain.

It does not guess.

It requires an explicit recovery decision.

This can be summarized simply:

If the system does not know what happened, it does not pretend that nothing happened.

That principle is increasingly important as AI systems are allowed to perform real work.

A Complete Controlled Workflow Has Now Been Built

The project has advanced significantly since its original prototype.

PMIVerse now includes a complete internal production-style workflow covering the major stages that would be required to operate AI workers safely.

The current system covers areas such as:

  • checking that the environment is ready;
  • verifying what work has been approved;
  • starting controlled AI workers;
  • coordinating implementation and review;
  • recovering safely after interruption;
  • preventing the same completed work from running twice;
  • handling cancellation;
  • cleaning up temporary work safely;
  • creating recovery checkpoints;
  • backing up and restoring system state;
  • updating the trusted execution environment;
  • monitoring the system;
  • recording incidents;
  • connecting through MCP for higher-level AI orchestration;
  • producing final evidence that can be checked independently.

The complete workflow currently consists of 32 defined stages.

All required stages are implemented.

The strongest qualification run has completed the entire workflow successfully.

The Current Qualification Result

The strongest current internal qualification is:

native-disposable-qualified

In simple terms, this means:

The complete PMIVerse workflow has been run successfully inside a controlled test environment using the real production components of the system.

This is much stronger than simply checking individual pieces of code.

The qualification runs the complete process from beginning to end.

It includes real system components, real communication between processes, real stored state, recovery, backup and restore, monitoring, AI-worker communication, and final verification.

At the same time, PMIVerse deliberately avoids making claims that have not yet been proven.

The current qualification does not automatically mean that a specific customer or production server has already been deployed and certified.

That is the next layer.

All Current Automated Tests Have Passed

The current project has a large automated test suite covering its safety, recovery, orchestration, execution, and reliability mechanisms.

During the latest formal assessment, most of the tests were run inside a restricted assessment environment.

A small number of host-specific tests could not run there because that environment did not provide the required operating-system capabilities.

Those remaining tests were then run separately by the administrator in the correct host environment.

They all passed.

The complete known automated test catalog has therefore now been executed successfully.

This is an important milestone because the earlier test gaps were caused by limitations of the assessment environment, not by missing implementation.

The System Can Prove That Completed Work Is Not Repeated

One of the strongest results demonstrated by the project is something called effect-free replay.

The idea is simple.

Imagine that a complex AI task has already completed.

Later, the same request is received again.

A weak system might run all the work again.

PMIVerse instead returns the result it already knows.

The qualification test goes further.

It verifies that during this replay:

  • no AI worker starts again;
  • no approval is consumed again;
  • no cleanup operation runs again;
  • no backup or restore runs again;
  • no system update runs again;
  • no new monitoring event is created;
  • no file in the observed environment changes.

The system simply returns the existing result.

This is a strong property for reliable automation.

Independent Verification

PMIVerse does not simply trust its own components when they say that a task was successful.

The system creates structured evidence about the work.

A separate verification process then checks that evidence.

It confirms things such as:

  • whether all required stages happened;
  • whether they happened in the correct order;
  • whether the correct software version was used;
  • whether the correct approvals were used;
  • whether recovery happened correctly;
  • whether backup and restore behaved correctly;
  • whether the correct AI-worker workflow ran;
  • whether important uncertainty was preserved rather than hidden.

This creates a stronger basis for trust than simply storing a transcript of what the AI said.

Safe Software Updates Are Part of the Design

The infrastructure that controls AI workers also needs to be updated over time.

That creates another risk.

If the control system changes while work is still running, the meaning of an existing operation could change.

PMIVerse therefore includes a controlled update process.

Before a new trusted runtime becomes active, the system can:

  • stop accepting new work;
  • allow existing work to finish;
  • verify that the system is safe to stop;
  • create and verify a backup;
  • move to the new version;
  • confirm that the new version is working correctly.

The old version is not automatically removed.

That remains a separate decision.

This approach is designed to avoid silent changes to the rules while AI work is already in progress.

Backup and Recovery Are Built In

PMIVerse treats operational history as important state.

That history includes information such as:

  • what was approved;
  • what already ran;
  • what completed;
  • what is still uncertain;
  • what version of the system was active.

The system includes a controlled backup and restore process that preserves this information.

After restoration:

  • completed work remains completed;
  • completed results remain available;
  • unresolved work remains unresolved.

The system does not rewrite uncertainty into success just because a backup was restored.

Monitoring and Incident Tracking

PMIVerse also includes its own monitoring and incident-evidence layer.

The system can observe its operational state and record important changes.

For example, it can identify when:

  • work is still active;
  • recovery is required;
  • an important checkpoint is missing;
  • the trusted runtime has changed;
  • the system has entered or left a degraded state.

These observations are kept separate from authority.

Monitoring can report a problem.

It cannot silently approve a solution.

ChatGPT and MCP Integration

The project already includes an MCP interface.

This provides a connection between high-level AI reasoning and the controlled execution system.

The intended model is:

Human
  │
  ▼
ChatGPT or another AI orchestrator
  │
  ▼
PMIVerse
  │
  ▼
Controlled coding agents

The higher-level AI can reason about what should be done.

PMIVerse remains responsible for deciding what is actually allowed to execute.

This avoids giving the orchestrating AI unrestricted access to the development environment.

The Project Is Not Tied to One AI Vendor

PMIVerse is intentionally designed around the idea of controlled workers rather than one specific AI model.

That is strategically important.

The leading AI provider may change.

Different customers may also prefer different models.

Some may prioritize:

  • performance;
  • privacy;
  • price;
  • data location;
  • contractual terms;
  • specialist capabilities.

The control infrastructure remains useful regardless of which AI model is behind it.

This makes PMIVerse potentially valuable as a provider-independent layer between organizations and increasingly autonomous AI systems.

What Has Already Been De-Risked

A significant amount of the core technical uncertainty has now been reduced.

The project has demonstrated:

  • a complete governed AI-workflow;
  • controlled implementation and independent review;
  • separation between approval and execution;
  • safe restart and replay behavior;
  • recovery after uncertain execution;
  • controlled cancellation;
  • safe backup and restore;
  • controlled software updates;
  • monitoring and incident evidence;
  • MCP integration;
  • bounded AI-worker communication;
  • independent final verification;
  • effect-free replay;
  • successful execution of the complete current automated test suite.

This means that the project is no longer primarily asking:

Can this architecture work?

The next questions are increasingly:

How should it be deployed, operated, integrated, and commercialized?

What We Are Working on Now

The core PMIVerse architecture and native workflow are now substantially implemented and qualified.

The project is therefore moving into a new phase: taking the proven technical foundation into real operational environments, integrating external AI providers, and preparing the system for broader practical use.

The current work is focused on the following areas.

Production Deployment

The next step is deploying and qualifying PMIVerse on its intended real production infrastructure.

This includes:

  • the actual server environment;
  • operating-system configuration;
  • service accounts;
  • resource limits;
  • real reboot behavior;
  • operational monitoring;
  • production backup procedures.

The goal is to move from a controlled qualification environment to a repeatable real-world operating environment.

Real AI Provider Integration

The current qualification uses a controlled deterministic AI-worker provider to verify the PMIVerse execution boundary.

We are now preparing the next step: connecting and qualifying real external AI providers.

This includes decisions around:

  • provider and model selection;
  • credentials;
  • secure network access;
  • privacy and data policies;
  • cost management;
  • provider availability;
  • failure and timeout handling.

The objective is to prove that the same controlled workflow remains reliable when the AI worker is powered by a real external model.

Operational Approval Infrastructure

PMIVerse already separates approval from execution.

The next phase is establishing how that approval model should operate in a real organization.

This includes:

  • who may approve sensitive operations;
  • secure signing-key storage;
  • approval workflows;
  • revocation;
  • key rotation;
  • audit procedures;
  • possible dual-control requirements for high-impact actions.

This work will turn the existing technical approval model into an organizational governance process.

Backup and Disaster Recovery

The system already includes governed backup and restore capabilities.

The next step is bringing these into a real operational environment with:

  • secure backup custody;
  • off-site storage;
  • encryption;
  • recovery procedures;
  • recovery-time objectives;
  • regular restore drills.

The purpose is not simply to create backups, but to prove that important execution history and unresolved state survive a real recovery scenario correctly.

Monitoring and Operations

PMIVerse already produces structured monitoring and incident information.

We are working toward integrating this with real operational systems for:

  • monitoring;
  • alerting;
  • incident management;
  • audit reporting;
  • long-term evidence retention.

The objective is to make the system practical for day-to-day operation, not only technically correct.

Performance and Scale

Development so far has concentrated primarily on correctness, control, recovery, and safety.

The next stage will also measure the system under realistic workloads, including:

  • larger software projects;
  • concurrent AI workers;
  • execution latency;
  • resource consumption;
  • provider response times;
  • operating costs;
  • reliability targets.

This will help define the practical performance and commercial operating envelope of the system.

Independent Review

As the production architecture stabilizes, independent technical and security review becomes increasingly valuable.

External review can help challenge:

  • the security model;
  • operational assumptions;
  • failure recovery;
  • approval infrastructure;
  • AI-provider boundaries;
  • deployment design.

The objective of this phase is no longer to prove that the core PMIVerse concept can work.

It is to turn the existing qualified foundation into a system that can be deployed, operated, integrated, and evaluated in real-world environments.

Where Investment and Sponsorship Can Help

The project has now reached a stage where support can be focused less on proving the basic idea and more on turning the system into operational infrastructure.

High-value areas include:

Production Deployment

Building and qualifying the first real operational environment.

Real AI Integration

Connecting and qualifying one or more commercial AI providers.

Security and Approval Infrastructure

Developing real organizational approval workflows, secure key management, revocation, and audit processes.

Monitoring and Operations

Connecting PMIVerse to real operational monitoring, alerting, incident management, and reporting systems.

Disaster Recovery

Creating real backup custody, off-site storage, recovery procedures, and recovery drills.

Independent Security Review

Having external specialists challenge the system, its threat model, and its operational design.

Performance and Scale

Testing realistic projects and workloads and determining the practical performance and cost envelope.

Commercial Integration

Developing easier interfaces, operator workflows, deployment tooling, and integrations for real organizations.

The Market Opportunity

AI software engineering is likely to become increasingly autonomous.

That creates a growing market for a new class of infrastructure.

The industry is already investing heavily in making AI models more capable.

But companies also need technology that answers a different set of questions:

  • What is the AI allowed to do?
  • Who approved the work?
  • Which systems may it access?
  • How do we stop it from going outside its assigned scope?
  • What happens if an operation fails halfway through?
  • How do we know whether it already happened?
  • How do we safely coordinate several AI workers?
  • How do we prove afterward what actually occurred?

Those problems do not disappear when AI models become better.

They become more important.

PMIVerse is being developed around the idea that this control and governance layer could become an important part of the future AI engineering stack.

A Provider-Independent Opportunity

The PMIVerse architecture is intentionally separated from the AI model itself.

That matters commercially.

The leading model today may not be the leading model tomorrow.

Different organizations may choose different providers because of:

  • privacy requirements;
  • cost;
  • regulation;
  • contractual terms;
  • performance;
  • data location;
  • specialist capabilities.

The need for governance remains regardless of provider.

Organizations will continue to need answers to questions such as:

  • Which AI acted?
  • What was it allowed to do?
  • Who approved it?
  • Which software could it change?
  • What happened if it failed?
  • Can the result be independently verified?

PMIVerse aims to provide that surrounding control layer.

Long-Term Vision

The long-term vision is easy to explain.

A developer says:

Investigate this problem.

Find what needs to change.

Implement the solution.

Test it.

Have another agent review it.

Recover safely if something fails.

Show me the result.

The developer does not need to supervise every individual command.

But the AI is also not given unrestricted control.

Instead:

Humans define goals and authority.

AI systems perform reasoning and engineering work.

PMIVerse controls what is allowed to happen.

The operating system enforces the boundaries.

The system preserves uncertainty instead of guessing.

Independent evidence records what actually happened.

The goal is not unlimited AI autonomy.

The goal is:

More autonomy without surrendering control.

Why Support PMIVerse

The central technical idea has moved beyond the concept stage.

The current native workflow is implemented.

The strongest qualification succeeds.

The complete current automated test catalog has been executed successfully.

The system independently verifies its final evidence.

Its replay model has demonstrated that completed work can be returned without repeating underlying effects.

The next phase is about converting this foundation into:

  • production deployment;
  • real organizational approval infrastructure;
  • real AI-provider qualification;
  • operational monitoring;
  • disaster recovery;
  • performance validation;
  • broader real-world adoption.

For investors, sponsors, and strategic partners, PMIVerse therefore represents an opportunity to participate at the transition between technical validation and operational application.

AI systems are becoming capable enough to perform meaningful engineering work.

PMIVerse is being built to help make that work controllable, recoverable, and trustworthy.

PMIVerse Multi-Agent Harness (technical)
The PMIVerse Multi-Agent Harness is a governed execution and orchestration system for AI-assisted software engineering.