A wide monitor on a dark desk showing an abstract seven-node workflow joined by lines, with abstract panels around it.

A Control Plane for Autonomous Agents

A control plane is the layer that decides what an autonomous agent may do, records what it did, and keeps the decisions that matter with people. Next-Generation Data Analytics LLC designs and builds governed AI systems and the data platforms beneath them, and this is how: the governance layer and the foundation built together, so the system is trustworthy by design rather than by convention.

Most teams can get an AI prototype working. Few can trust it in production: autonomous agents need clear limits, verifiable output, and a record of what happened, and they need a reliable data and DevOps foundation underneath. The sections below are the properties that answer each of those needs, in the order a change travels through them.

Six Properties, One Path Through Them

Policy-as-code governance

Policy-as-code guardrails that limit what an agent may do.

Read on about policy-as-code governance

Credential-free execution

Credential-free agent execution: the secret stays outside the agent’s context.

Read on about credential-free execution

Human approval gates

Human-in-the-loop approval gates: automation does the work and people approve each gate.

Read on about human approval gates

CI verification and conformance

Executable acceptance criteria run in CI, with conformance checks beside them.

Read on about ci verification and conformance

Versioned engine, pinned

The engine is versioned, and a tenant runs the version it pins.

Read on about versioned engine, pinned

Audit trail and provenance

Audit trail and provenance design, from intent to merged change.

Read on about audit trail and provenance

Objective to Merge, One Gate at a Time

Every change an agent makes travels one path: an objective becomes a design, a design becomes a plan, a plan becomes a job, a job becomes a pull request, and nothing merges until a person approves the gate. Each stage carries a state, and the state is written on the page in words as well as in colour — verified, executing, awaiting a human, queued, blocked. The row below is HTML and CSS with the states as data; it is not a screenshot, and it reports no number from any running system.

  1. Objective Discover and scope verified
  2. Design Specify, criteria executable verified
  3. Plan Gated increments verified
  4. Job Automation does the work verified
  5. Pull Request Verified in CI verified
  6. Human Gate A person approves human
  7. Merge Hand off and harden verified

The governance boundary

Autonomous execution ends where authority begins. That line is the whole point of the lifecycle above.

  1. The agent executes Inside the limits policy-as-code places on what an agent may do. executing
  2. A human decides The gate is a person: nothing merges without an approval. human

Policy-as-Code, Not Prose Rules

Policy-as-code guardrails limit what an agent may do: the limits are written as code and enforced where the agent runs, so what an agent may touch is a property of the policy rather than of a paragraph someone hoped it had read. NGDA prefers deterministic gates over prose rules, and AI governance is built in rather than bolted on.

The policy and the system are designed together. The same pass that maps a workflow, its data sources and its constraints also settles which decisions must stay with people, and those decisions become the gates further down this page.

Credential-Free Execution

An agent does not hold a credential of its own. The control plane authorizes the step, and the secret stays outside the agent's context, so the question “what could this agent reach?” is answered by the policy and not by whatever happened to be handed to it.

The same discipline applies to the repositories agents work in: secrets reach an application from its environment, are never printed or logged, and are never committed. This website's own repository is held to that rule.

Human Approval Boundaries

Human-in-the-loop approval gates are part of the architecture, alongside orchestration, tool and function calling, context management, multi-step handoffs and persisted run state. Automation does the work; people approve each gate.

Which decisions stay with people is not left to the moment. It is mapped at the start, with the workflow, the data sources and the constraints, and the map is what the gates implement. A gate that a person has not passed is a change that has not merged.

Deterministic Conformance, Verified in CI

Specifications carry executable acceptance criteria, so “done” is testable rather than asserted. Tests, schema and contract validation, and conformance checks run in CI on every change.

Verification itself is held to a standard: NGDA checks whether a test or a metric can actually detect failure before trusting it, and evaluates LLM judges and metrics honestly rather than treating a passing score as evidence. An instrument that reports the same thing on unmodified work has reported nothing.

A Versioned Engine, Pinned per Tenant

The control plane's engine is versioned, and a tenant runs the version it pins. An engine release therefore does not change a tenant's behaviour until that tenant moves to it, which is what lets a conformance check mean the same thing months after it was written.

This website's repository is one such tenant: its own methodology pack declares the engine range it targets, beside the rules it injects and the verify target its gate runs. The pin is a file in the repository, so it is reviewable in a pull request like anything else.

Auditability and Provenance

Audit trail and provenance design is part of the build, not a report written afterwards: a full audit trail runs from intent to merged change, so each change can be traced back to the objective that asked for it and the gate that let it through.

Operation feeds the same record. Documentation, runbooks and monitoring are handed over with the system, and every production lesson becomes an enforced check rather than a wiki note.

NGDA’s Own Products, Governed Through It

NGDA governs its own work this way. ZoneVista (zonevista.io) is a production real estate analytics SaaS architected and operated by NGDA's principal, with SQL validation of every materialized view before changes ship. ngda-bidder is an LLM document-analysis pipeline on the Anthropic API that extracts structured requirements from RFPs and scores them against evaluation criteria. This website is the third: its repository carries the methodology pack that holds the rules, the engine range and the verify target, and every change to it arrives as a pull request a person merges.

Separately, and in employment, as AI Architect (2025–present), David Walters architects and implements an agentic AI platform for a regulated automotive environment, including agent lifecycle control, credential-free agent execution, human-in-the-loop gates, CI verification, and production tenant operations. That work belongs to the employer and the role; NGDA does not own it, and no employer or customer of an employer endorses NGDA. The employment entries are on the founder page.

Bring This to Your Own Agents

If you have agents working and no way to prove what they did, that is the conversation to have. NGDA engages as an independent contractor: senior architecture and hands-on engineering in one person, from the governance layer to the infrastructure underneath it.