AVMOS

Autonomous Verification, Monitoring & Operations System.

Comment

AVMOS

AVMOS (Autonomous Verification, Monitoring & Operations System) is an autonomous infrastructure operations platform.

It connects real infrastructure telemetry to AI reasoning, deterministic policy enforcement, controlled execution, and auditing.

AI proposes. Policy authorizes. Protected execution executes.

The Problem

Monitoring can tell you something is wrong. It does not solve the problem.

When infrastructure crosses a threshold, someone still has to:

  • verify the condition
  • understand what is happening
  • determine what action should be taken
  • check whether that action is allowed
  • execute it
  • verify the result

AVMOS is designed to automate that workflow while keeping critical actions governed.

How It Works

Real Infrastructure → New Relic → Verification → Grok → Policy → Execution → Audit

  • New Relic provides real infrastructure telemetry.
  • AVMOS verifies the telemetry and its freshness.
  • Grok analyzes the verified state and produces a structured action proposal.
  • A deterministic policy engine evaluates whether that proposal is allowed.
  • Only approved proposals reach the protected execution layer.
  • The result is recorded for auditing.

The AI does not directly authorize an action, sign a transaction, or bypass policy.

What We Built

The prototype uses a real infrastructure resource monitored through New Relic.

AVMOS can observe an operational condition, verify the evidence, use Grok to reason about the condition, generate a structured action proposal, and evaluate that proposal against deterministic policy.

The result is either:

APPROVE → execute

or

DENY → stop before execution

The current execution path uses XRPL Testnet and RLUSD to demonstrate governed machine-to-machine settlement without giving the AI unrestricted access to a wallet.

The policy layer can enforce constraints such as:

  • resource and action permissions
  • transaction limits
  • budgets
  • approved vendors
  • telemetry freshness
  • evidence requirements
  • duplicate-remediation protection

What Makes AVMOS Different

AVMOS is not just another monitoring dashboard and it is not an AI chatbot for servers.

The key design decision is the separation between reasoning and authority.

The model can say:

“I propose this action.”

It cannot say:

“I am allowed to execute this.”

That decision belongs to the deterministic policy engine.

This allows increasingly capable AI to participate in infrastructure operations without giving the model unrestricted control over critical systems.

Bottlenecks & Obstacles

Building AVMOS as a solo engineer meant the architecture had to evolve as real technical constraints appeared.

One of the biggest changes was moving away from simulated monitoring data toward real New Relic telemetry. Autonomous infrastructure decisions need real, verifiable evidence, not fabricated dashboard values.

The execution model also changed during development. Instead of allowing an agent to directly control infrastructure or financial execution, the system was redesigned around a strict:

AI → Policy → Protected Executor

boundary.

Other bottlenecks included authentication and public/private route separation, realtime application state, scheduled processing, persistent operational records, idempotency, CI failures, deployment issues, and integrating multiple external systems without allowing those integrations to bypass the security model.

I also deliberately avoided building an unrestricted SSH or shell-remediation agent. The goal was to prove the governed decision and execution model without giving an autonomous system unnecessary access to the underlying machines.

Pivots

The project went through several architectural changes during development:

Simulated data → real New Relic telemetry

Direct agent authority → AI reasoning + deterministic policy

Unrestricted remediation → protected execution

Single-purpose payment flow → provider-independent execution architecture

Each change came from encountering a real engineering or security constraint rather than simply adding features.

Solo Engineering

AVMOS was built as a solo engineering project.

I designed and implemented the architecture, infrastructure integrations, backend, policy system, execution safeguards, frontend, authentication boundaries, deployment configuration, testing, and the supporting infrastructure required to run the system.

Working alone also meant prioritizing the core problem and repeatedly simplifying the design when a feature added complexity without strengthening the product.

What I Learned

The hardest part wasn't getting an AI model to generate an action.

The hardest part was deciding who is actually allowed to execute it.

That led to the core AVMOS principle:

The model proposes. The policy engine decides. The executor acts.

That separation became the foundation of the entire system.

What's Next

AVMOS is being designed as a provider-independent operations layer rather than a system tied to one payment or execution platform.

The same policy and authorization model can eventually support different execution providers and operational workflows.

The long-term goal is an infrastructure operations layer that can:

Monitor → Verify → Reason → Authorize → Act → Audit

while keeping autonomous systems observable, constrained, and accountable.

Why AVMOS

Infrastructure already generates enormous amounts of telemetry.

The missing layer is often what happens between:

“Something is wrong.”

and

“Something was safely done about it.”

AVMOS is designed to fill that gap.

Built With

Share this project:

Updates

Submission history