4. Multi-Model and Multi-Agent AI Systems: Infrastructure Implementation Guide

Featured Content - Research and Perspectives

4. Multi-Model and Multi-Agent AI Systems: Infrastructure Implementation Guide

Posted on 09.01.26
Web Agentic AI. v1.indd4

Containerization and Runtime Isolation

Running the stack requires eight container types, each with a strictly bounded scope.

 

  • At the center is the orchestrator. It enforces the capability manifest, resolves prompts, gates tool grants, manages HITL evaluation, and tracks every workflow with a correlation ID. Security posture: non-root user, no host network access, egress only to defined endpoints, read-only root filesystem. (AC-3, AC-6, SC-7)
  • Agent containers run one per role, never shared. LLM calls happen here, along with output schema validation, confidence scoring, and explainability generation. Agents have no direct paths to each other; the orchestrator message bus is the only route. Memory limits are hard-enforced. (AC-3, SC-4, SI-10)
  • MCP server containers are the narrowest in scope: one per tool domain, one target system, no persistent local state. Credentials arrive at startup via the secrets vault sidecar, not baked into the image. (AC-6, SC-7, SA-9)
  • The code execution sandbox is the most locked-down layer. gVisor or Firecracker provides kernel-level isolation, network egress is blocked, the filesystem is ephemeral per invocation, and execution timeout is enforced at the container runtime layer. (SI-3, SC-39, SA-8)
  • The prompt farm and tool registry are both strictly read-only at runtime. Every prompt read is logged. The registry holds tool identifiers, descriptions, and MCP endpoint references with no credentials and no overlap with the prompt farm. (CM-3, CM-6, AU-12, AC-3)
  • Two sidecars complete the stack. The secrets vault sidecar injects credentials as environment variables scoped to the container’s lifetime, nothing written to the filesystem, CMK keys managed here too. (SC-12, SC-28, IA-5) The observability sidecar reads stdout/stderr from every container in the stack and writes only to the observability pipeline. (AU-2, AU-12, SI-12)

 

Base Image Requirements
  • Use minimal base images (distroless or Alpine only, no package manager, shell, or debugging tools in production).
  • Pin all base image versions to specific digest hashes; never use floating tags.
  • Scan images for vulnerabilities at build time and before deployment, blocking deployment on critical/high CVEs, and cross-reference against the CISA KEV catalog: KEV-listed vulnerabilities must be remediated or have an approved mitigation plan before deployment.
  • Generate an SBOM for every image (Syft or Trivy; SPDX or CycloneDX format, NTIA minimum elements) per EO 14028, with delivery and format terms flowing from agency contract terms and current OMB guidance (M-26-05); confirm with the contracting agency.
  • Separate build-time and runtime dependencies: data analysis libraries belong in the code execution sandbox image, not agent or orchestrator images.

 

Runtime Security Policies
  • Enforce read-only root filesystem for all containers except designated state store mounts.
  • Drop all Linux capabilities on container start; add back only specific capabilities required.
  • Apply seccomp profiles to restrict available syscalls, using a restrictive custom profile for code execution sandboxes.
  • Never mount the Docker socket or Kubernetes API server credentials into a container.

Safe Code Execution Architecture

The primary threat is an LLM generating code that, when executed, causes unintended consequences: data exfiltration, filesystem modification, resource exhaustion, or lateral movement. The sandbox must contain these consequences regardless of what code the LLM generates.

 

Sandbox Controls

The sandbox relies on ten layered controls. They fall into three groups.

Isolation controls. At the kernel level, gVisor or Firecracker microVMs intercept all syscalls before they reach the host kernel, preventing host kernel exploits from malicious LLM-generated code. No network egress is permitted from the sandbox, DNS resolution is disabled, all outbound connections are blocked, closing off data exfiltration, C2 callbacks, lateral movement, and credential theft via network scan. The execution environment is created fresh from an immutable base image on every invocation, with a tmpfs filesystem destroyed after execution, so nothing persists between runs.

Resource controls. Execution timeout is enforced at the container runtime layer, not the application layer, catching infinite loops and resource exhaustion before they affect adjacent workloads. cgroup limits cap CPU and memory hard, sized to the data analysis workload. Input data is mounted read-only from the calling agent’s authorized scope; the sandbox cannot write to it.

Operational controls. The sandbox runs as a non-root, non-privileged user with no sudo access. The container image includes only an explicitly approved list of data analysis libraries, the package manager is disabled or removed, preventing arbitrary dependencies and supply chain attacks via LLM-suggested pip install commands. Execution output is capped at a configurable size limit; oversized output is truncated and flagged for HITL review. Every execution event logs the requesting agent role, code hash, execution duration, exit code, output size, and sandbox ID.

 

Kernel-Level Sandboxing Options
  • gVisor (runsc): A user-space kernel that intercepts all syscalls before they reach the host kernel. Provides strong isolation with workload-dependent overhead: CPU-bound workloads such as data analysis see minimal to no overhead; I/O-intensive and network-heavy workloads incur higher overhead. See gvisor.dev/docs/architecture_guide/performance for current benchmarks (Google, 2024).
  • Firecracker microVMs: Lightweight virtual machines with a separate kernel per execution. Stronger isolation than gVisor. Boot time under 125ms per the official specification (Amazon Web Services, 2024), viable for warm pool designs.

 

Warm Pool Design
  • The warm pool should be sized to peak concurrent code execution demand plus 20% buffer.
  • Each warm instance is claimed exclusively by one workflow invocation, used, and then destroyed. Instances are never reused across invocations.
  • Overflow requests queue with a configurable maximum wait time. Requests exceeding the maximum wait return a queue-full response to the calling agent.

Scalability Architecture

Scaling strategy varies considerably across the stack because the constraints aren’t uniform.

  • The orchestrator runs at a minimum of two instances for HA and scales horizontally on HTTP queue depth and active session count. Session affinity is required, either sticky sessions or a shared state store, because a session mid-flight can’t be handed off cleanly without losing correlation context.
  • Agent containers are the opposite: minimum zero. They scale down when idle and come up on demand because each invocation is stateless, resolving prompt and tool grants fresh from the manifest every time.
  • MCP server containers scale per domain, not per agent role. One minimum per domain kept warm. The actual binding constraint isn’t compute; it’s the target system’s own rate limits.
  • The code execution sandbox runs a warm pool with overflow queuing rather than standard autoscaling. Seventy percent pool utilization triggers expansion; recommended starting size is three to five instances. Every sandbox is single-use and ephemeral.
  • The prompt farm scales through read replicas triggered at p95 latency above 50ms. Cache aggressively; this service is almost entirely reads. Two minimum instances for HA.
  • Vector stores and memory need vertical scaling and horizontal sharding. Shard by data classification boundary rather than just by load. PHI and non-PHI should not share a shard.
  • The HITL interface scales like a standard web application. The throughput ceiling is the human reviewers, not the infrastructure. Scaling the interface doesn’t fix reviewer capacity.
  • The observability pipeline is pre-provisioned at 2x peak, no autoscaling trigger. Log drops are not an acceptable failure mode. Build it oversized from day one.

LLM Token Throughput Management

Size provisioned throughput (PTU) to peak concurrent session count multiplied by average tokens per agent invocation, with 25% headroom. Assign each workflow run a token budget at initiation: orchestrator escalates to HITL as the budget approaches exhaustion. Route classification and routing agents to efficient models; reserve capable models for synthesis and generation. Implement a token bucket or leaky bucket rate limiter in front of all LLM API calls.

Network Topology, Zone Segmentation, and CISA Zero Trust Maturity Model Alignment

Network segmentation in a multi-agent system is where the trust boundaries defined in the capability manifest get enforced at the infrastructure layer. Each zone below maps to a specific CISA Zero Trust Maturity Model pillar (ZTMM v2.0, 2023), giving federal programs a concrete path to EO 14028’s zero trust requirements.

EO 14028 requires federal agencies to develop and implement zero trust architecture plans. CISA’s Zero Trust Maturity Model (ZTMM v2.0) defines five pillars: Identity, Devices, Networks, Applications and Workloads, and Data, each with Traditional, Initial, Advanced, and Optimal maturity stages. The zone architecture in this section addresses all five pillars. Programs should assess where they currently sit on the ZTMM scale and treat this architecture as the target state for their AI systems.

The network architecture divides into eight zones, each with explicit inbound/outbound rules and encryption requirements.

 

  1. Starting from the outside, traffic enters through the external/user zone: end-user clients, analyst workstations, and the HITL review interface. HTTPS/WSS only on defined ports, authenticated sessions required, no direct outbound paths to internal systems. TLS 1.3 minimum.
  2. The API gateway/ingress zone is where TLS terminates, authentication is enforced, and rate limiting applies before anything reaches the orchestrator. The gateway re-encrypts for the downstream hop.
  3. From there, the orchestrator zone holds the orchestrator containers, session state store, and correlation ID manager. Inbound only from the ingress zone; outbound via mTLS to the agent zone’s message bus, the prompt farm, and the observability pipeline.
  4. The agent zone keeps agent containers isolated from each other. The only inbound path is through the orchestrator message bus. Outbound is authorized tool calls to the MCP server zone, signed with agent identity.
  5. Each MCP server container connects to exactly one target system. Inbound from the agent zone only; outbound to that specific target system only. Credentials come from the vault sidecar, not the image.
  6. The code execution zone has no network egress at all. Inbound from agents only, data mounts are read-only, the filesystem is ephemeral. Nothing leaves this zone over the network.
  7. The data zone (vector store, memory stores, audit logs, prompt farm, tool registry) accepts inbound from orchestrator, agent, and MCP zones as authorized. The only outbound path is audit logs to the SIEM pipeline. CMK encryption at rest, TLS 1.3 in transit.
  8. The observability zone collects append-only log streams from every other zone and forwards to the SIEM or external platform. Log stream integrity is verified via hash chain. It reads from the rest of the stack but can’t affect application state.
CISA ZTMM Maturity Mapping

This architecture reaches Advanced maturity on four of five pillars, Initial to Advanced on the fifth:

  • Identity (Advanced): mTLS with service identity certificates for all inter-service communication; OAuth 2.1 for external authentication; agent identity tied to capability manifest role. Path to Optimal: continuous identity verification and behavioral analytics per session.
  • Devices (Advanced): Vulnerability/KEV scanning and digest-pinned deployments prevent unauthorized image substitution. Path to Optimal: real-time device posture assessment and automated remediation.
  • Networks (Advanced): Explicit zone segmentation with no lateral movement paths between agent containers. Path to Optimal: process-level microsegmentation and automated policy generation from observed traffic.
  • Applications and Workloads (Advanced): Defined, enforced communication boundary per agent container; least-privilege tool grants. Path to Optimal: continuous runtime behavior monitoring and automated anomaly response.
  • Data (Initial to Advanced): CMK encryption at rest; data classification enforced at the manifest level; PHI/PII scrubbing before embedding. Path to Optimal: automated data classification and policy enforcement at the data element level.
Web Agentic AI. v1.indd4

Transport Layer: Websocket Architecture for Real-time Agent Workflows

WebSocket is preferred over REST for agentic workflows for three reasons: it lets the orchestrator stream partial results to the UI in real time; a multi-agent workflow may run 30–120 seconds, and WebSocket maintains a persistent connection over that span; and bidirectional HITL gate payload push and decision receipt is natural in WebSocket.

Implementation requirements: authenticate at connection establishment (token validation at the API gateway before the HTTP-to-WebSocket upgrade); scope each connection to exactly one session and one correlation ID; use application-level heartbeats at defined intervals; and define maximum message sizes for inbound and outbound messages, rejecting oversized messages.

Observability and Behavioral Monitoring

The observability pipeline collects ten categories of signals, grouped below by what they’re monitoring.

 

Core workflow signals. Distributed traces follow each workflow end-to-end via correlation ID, capturing agent transitions, tool calls, model invocations, HITL gate events, and explainability events. Alert when P99 latency exceeds 2× baseline for any segment (AU-12, IR-4). Tool call audit logs capture agent role, tool ID, input parameters redacted for sensitive fields, result status, execution duration, and MCP server ID, alert on any tool call by an agent role not in its manifest allowed_tools[] (AU-2, AU-3, AC-3). Model invocation logs record agent role, model ID, model version, token count, latency, and confidence score; alert on manifest pin mismatches and on confidence scores below threshold without HITL escalation (CM-6, AU-12).

Governance signals. HITL gate logs record gate ID, agent role, output summary hash, reviewer identity, decision, decision latency, and timestamp. Two alert conditions: gate bypassed without a recorded decision, and reviewer queue age exceeding SLA (AC-3, PM-14, AU-9). Prompt version logs capture every resolution event: agent role, prompt_ref, resolved version, timestamp, and correlation ID. Alert when a prompt resolves to an unexpected version or the prompt_ref isn’t in the farm (CM-3, AU-12).

Operational signals. Code execution logs capture sandbox ID, requesting agent role, code hash, execution duration, exit code, output size, and timeout events. Alert on non-zero exit code, timeout, output at size limit, or execution by an unexpected agent role (SI-3, AU-12). Container health metrics cover CPU/memory utilization, restart count, OOM events, and network connection count per zone, alert when memory hits 85% of limit, restart count exceeds two in ten minutes, or an unexpected outbound connection attempt is detected (SI-17, SC-7). Scaling event logs capture autoscaling trigger events, metric, threshold crossed, new instance count, and warm pool utilization; alert on sustained pool utilization above 90% and on scale-up events during off-peak hours (SI-17, IR-5).

Safety and security signals. Confabulation incident logs cover manually or automatically flagged outputs where an agent generated unverified specifics. Any confirmed confabulation event triggers root cause review within 24 hours (SI-10, IR-4). Secrets access logs record every credential retrieval from the vault: requesting container identity, secret identifier (not value), and timestamp. Alert on retrieval by an unexpected container identity and on high-frequency retrieval patterns (IA-5, AU-2).

 

EO 14028 Log Retention and Sharing Requirements

EO 14028 Section 8 adds log retention and sharing obligations that go beyond what NIST 800-53 AU controls alone require.

  • Retention. Agency policy sets the minimum retention period, typically two years for operational logs and longer for audit logs; confirm the schedule and record it in the System Security Plan.
  • CISA log exports. CISA needs selective log exports during incident investigations; configure the pipeline to support export by time range, system identifier, and event type.
  • EDR telemetry. On federal infrastructure, EDR telemetry from all containerized components is required and feeds into the agency’s EDR solution.

CI/CD Pipeline for Agentic Systems

The CI/CD pipeline runs nine gates, each targeting a specific failure mode.

Pre-commit hooks catch the cheap stuff early: prompt content with embedded secrets, linting failures, schema syntax errors. The PR gate goes deeper, running unit tests, schema correctness, prompt behavioral regression, dependency vulnerability scan, and SBOM generation with a KEV scan before anything merges.

Staging deploy is where behavioral checks requiring a full running system happen: end-to-end workflows, confabulation regression, HITL gate trigger accuracy, audit log completeness, and explainability output. A failure blocks promotion.

Manifest changes get a human gate: review of the diff, downstream impact analysis, regression testing for affected agent roles, and security officer sign-off if the change touches HITL configuration, data classification, or explainability settings.

Model version upgrades and prompt version updates each run dedicated regression gates. For models, that’s a full behavioral baseline comparison, schema compliance rate, confabulation rate, and explainability quality on a test corpus. Failure rolls back to the prior model_id. For prompts, behavioral regression and no-confabulation block effectiveness are checked; failure retains the prior version.

The pre-deployment SBOM and KEV gate confirms coverage for all custom components, clean scan or approved mitigation on file, and SSDF attestation for third-party components. Production deploys blue/green with a health check before traffic shifts. Post-deploy canary monitoring runs 30 minutes against the pre-deploy baseline across error rate, latency, confidence distribution, confabulation incident rate, and explainability output. Any degradation triggers automatic rollback.

Operational Resilience and Disaster Recovery

Most failure scenarios in this stack have a defined recovery path. A few don’t have graceful fallbacks, and those are worth understanding explicitly.

Single agent container failures are handled by the orchestrator: route to a healthy replica immediately, restart the failed container. Correlation ID continuity is maintained throughout. Under 30 seconds.

MCP server failures follow the same pattern if a healthy replica exists. If none are available, the workflow pauses and HITL gets notified rather than failing without signal. Target RTO under 60 seconds.

Code execution sandbox failures (timeout or non-zero exit) return a failure to the calling agent and replace the sandbox from the warm pool. Recovery is intentionally at the workflow level, not the infrastructure level. Under 30 seconds.

Orchestrator failure is where day-one architectural decisions matter. A new instance picks up from the shared state store and resumes from the last checkpoint. Without externalized state, orchestrator failure means session loss. RTO under two minutes with the state store in place.

Prompt farm unavailability is the one scenario without a graceful fallback. New workflow starts halt immediately. In-flight workflows run on cached prompts. Recovery requires a backup restore. Given how central the prompt farm is to the trust model, operating on stale prompts isn’t viable.

Vault outages cause MCP containers to fail at startup since credential injection depends on the vault. Tool calls queue; the orchestrator drops to degraded mode. Vault HA keeps RTO under five minutes.

LLM provider outages activate the fallback model_id from the manifest if one is defined. If there’s no fallback, workflows pause and HITL gets notified. Nothing in the infrastructure determines the RTO; that depends entirely on the provider.

Zone failures fail traffic to the secondary zone, with sessions resuming from the shared state store. Active-active configuration gets this under five minutes.

 

Graceful Degradation Tiers
  • Tier 1. Full capability: all components healthy.
  • Tier 2. Code execution degraded: analytical workflows requiring code execution are queued or declined.
  • Tier 3. Memory degraded: sessions proceed without memory context.
  • Tier 4. Read-only mode: MCP servers with write tool access unavailable; write operations queued.
  • Tier 5. HITL only: no automated workflow processing; HITL interface remains available.

Runbook requirements: tested in staging before production deployment; updated every time the architecture changes; accessible to on-call personnel without production system access; specific enough to follow without subject matter expert guidance.

AI Incidence Response Plan

IT disaster recovery covers infrastructure failures. An AI Incident Response Plan (AI IRP) covers a different problem: the system behaving in ways that cause harm even when all the infrastructure is running fine. The two overlap but aren’t the same. What follows is the AI IRP structure for multi-agent systems operating in or adjacent to federal environments.

EO 14028 Section 5(b) requires federal agencies and their contractors to report cybersecurity incidents to CISA within 72 hours of discovery. For AI systems, the reportable incident definition extends beyond traditional cybersecurity events to include adversarial attacks via prompt injection, model output manipulation causing operational harm, and unauthorized access achieved through AI agent privilege escalation. These events fall under the same 72-hour obligation.

 

AI Incident Classification

Four classifications cover the incident space. The line between them matters primarily for reporting obligations.

  1. AI Security Incidents are situations where the infrastructure is actively working against you: prompt injection attacks, privilege escalation through agent manipulation, unauthorized data access via AI workflow, or model output weaponized against users or systems. The 72-hour CISA clock starts at discovery. Agency CISO notification within 4 hours. Capture a forensic snapshot before remediation, isolate the affected containers, preserve all logs and trace data, activate HITL-only mode.
  2. AI Safety Incidents mean demonstrable harm from AI behavior regardless of whether the infrastructure was compromised: a confabulation that drove a wrong decision, a dangerous recommendation acted on, output affecting user safety, or systematic bias producing discriminatory outcomes. Report to the AI governance office within 24 hours; disclose to affected users per policy. Halt automated workflows in the affected domain, review outputs from the affected agent for the prior 48 hours, and start root cause analysis.
  3. AI Operational Anomalies sit below the incident threshold but need tracking: elevated confabulation without demonstrated harm, schema failure rate spikes, confidence distribution shift, HITL escalation rate outside normal range. System owner notification within 8 hours, documented in the operational log. Increase monitoring verbosity, review recent prompt or model changes, and don’t halt workflows without actual evidence of harm.
  4. AI Performance Degradation covers latency, throughput, and error rates with no safety or security angle. Standard incident management applies; no AI-specific escalation path needed.
CISA 72-Hour Reporting Procedure
  • Step 1 (0-4 hours): The on-call responder confirms the event meets AI Security Incident criteria, captures a forensic snapshot of all logs, traces, and container states, and notifies the agency CISO and system owner.
  • Step 2 (0-4 hours): Containment. Isolate affected agent containers, activate HITL-only degradation, preserve all evidence. Don’t remediate or restart anything until the forensic snapshot is confirmed complete.
  • Step 3 (within 72 hours of discovery): Submit the incident report to CISA via the reporting portal or agency-designated channel. Required fields: system identifier, incident type, discovery date and time, affected components, initial impact assessment, containment actions taken, and point of contact. This report is preliminary; full findings follow separately.
  • Step 4: Investigation. Reconstruct the incident using distributed traces and correlation IDs, identify the attack vector, affected agent roles, tool calls made, data accessed, and outputs produced.
  • Step 5: Remediation and recovery. Address the root cause before restoring automated workflows, update manifest/prompt/schema as needed, run the full regression suite, and restore operations tier by tier starting from Tier 5.
  • Step 6 (within 72 hours of closure): Structured after-action review. Update the IRP, runbooks, and detection rules based on findings. Report to the AI governance office.

 

STAKEHOLDER NOTIFICATION MATRIX

Stakeholder

AI Security Incident

AI Safety Incident

AI Operational Anomaly

Agency CISO

Within 4 hours

Within 24 hours

Not required

CISA

Within 72 hours per EO 14028

Not required (unless it results from a security event)

Not required

Agency AI Governance Office

Within 24 hours

Within 24 hours

Within 8 hours

System Owner

Within 4 hours

Within 8 hours

Within 8 hours

Affected Users

Per agency disclosure policy; typically within 72 hours if personal data exposed

Per agency policy; disclose if output affected user welfare

Not required

Contracting Officer

Within 24 hours if contractor system

Within 48 hours if contractor system

Not required

AI System Decommissioning

Multi-agent systems accumulate sensitive data in a lot of places: vector indices, memory stores, audit logs, session state, prompt versions, and model artifacts. Without a cleanup plan, that data stays in place, audit trails go unarchived, and retention obligations go unmet.

 

Pre-Decommissioning Checklist

Users need at least 30 days’ notice before system retirement, along with alternative workflows for the functionality they’re losing. All pending HITL reviews must be resolved before decommissioning starts. Export and archive the complete audit log record before anything else is touched. Verify archive integrity and confirm the applicable retention period with agency policy (federal systems typically run seven years for audit logs). Capture the final system state as part of the permanent record: agent role definitions, active prompt versions, deployed model versions, and tool grants in effect.

 

Data Deletion Procedures

Vector store deletion means a full namespace deletion for all associated namespaces, confirmed complete and irreversible. For regulated data (PHI, PII, classified), get a deletion certificate from the storage provider or generate one internally.

Tiered memory architectures need to be cleared in order: raw transcripts first, then scrubbed embeddings, then preference summaries. Confirm each tier is empty before moving on. Session state gets the same treatment: clear all records, verify no orphaned correlation IDs, purge the index.

Prompt farm: archive all versions to long-term records storage, then delete the active namespace. Keep the archive for the full retention period. Vault cleanup means revoking all system-associated credentials, deleting all secrets, and rotating any that were shared with other services; log the revocations in the vault audit trail.

Pull all system container images from the registry and keep manifests (not the full images) in the artifact archive for the retention period.

Recommendations

The infrastructure layer described in this article is not an optional enhancement for a multi-agent AI system. It is the mechanism by which the governance decisions in Arti les 1 through 3 become enforceable. A capability manifest without container isolation is a policy document with no enforcement point. A code execution agent without a sandbox is an arbitrary code execution vulnerability. An orchestrator without distributed tracing is an unauditable black box. The architecture is only as secure as its implementation.

  • Implement kernel-level sandboxing (gVisor or Firecracker) for all code execution containers before deploying any agent that can execute LLM-generated code.
  • Generate SBOMs for all container images and scan against the CISA KEV catalog in the CI/CD pipeline before every production deployment.
  • Map the system’s network zone architecture to the CISA Zero Trust Maturity Model and document current and target maturity stages in the System Security Plan.
  • Implement the AI Incident Response Plan before go-live, including the CISA 72-hour reporting procedure and stakeholder notification matrix. The IRP must be tested in a tabletop exercise before production deployment.
  • Define and document the decommissioning procedure at system design time. Do not wait until decommissioning is imminent.
  • Externalize orchestrator session state to a shared state store, implement distributed tracing with correlation ID propagation, and build the behavioral regression test suite as first-class deliverables before go-live.
  • Use WebSocket for all client-to-orchestrator connections in interactive analyst workflows.

References

Meinert, I. (2026). Series article 7: Model Context Protocol (MCP) servers in enterprise AI architecture. Aptive Resources.

Meinert, I. (2026). Series article 6: Multi-model and multi-agent AI workflows: Architecture, risk and DevSecOps controls. Aptive Resources.

Meinert, I. (2026). Series article 5: The orchestrator capability manifest. Aptive Resources.

Meinert, I. (2026). Series article 4: Multi-model and multi-agent AI systems: Infrastructure implementation guide. Aptive Resources.

Meinert, I. (2026). Series article 3: Organizational AI governance: Frameworks, artifacts and implementation guidance. Aptive Resources.

Meinert, I. (2026). Series article 1: NIST AI RMF 1.0 alignment analysis: Three-state coverage assessment and gap remediation roadmap. Aptive Resources.

Amazon Web Services. (2024). Firecracker specification. https://github.com/firecracker-microvm/firecracker/blob/main/SPECIFICATION.md

Cybersecurity and Infrastructure Security Agency. (n.d.). Known exploited vulnerabilities (KEV) catalog. https://www.cisa.gov/known-exploited-vulnerabilities-catalog

Executive Office of the President. (2021, May 12). Executive Order 14028: Improving the nation’s cybersecurity. Federal Register, 86(93), 26633–26661. https://www.federalregister.gov/documents/2021/05/17/2021-10460/improving-the-nations-cybersecurity

Cybersecurity and Infrastructure Security Agency. (2023, April). Zero trust maturity model, Version 2.0. https://www.cisa.gov/sites/default/files/2023-04/zero_trust_maturity_model_v2_508.pdf

Google. (2024). gVisor performance guide. https://gvisor.dev/docs/architecture_guide/performance/

 

Joint Task Force. (2020). Security and privacy controls for information systems and organizations (NIST SP 800-53, Rev. 5). National Institute of Standards and Technology. https://doi.org/10.6028/NIST.SP.800-53r5

Tabassi, E. (2023). Artificial intelligence risk management framework (AI RMF 1.0) (NIST AI 100-1). National Institute of Standards and Technology. https://doi.org/10.6028/NIST.AI.100-1

Dodson, D., & NIST. (2022, February). Secure software development framework (SSDF), Version 1.1 (NIST SP 800-218). National Institute of Standards and Technology. https://doi.org/10.6028/NIST.SP.800-218

Rose, S., Borchert, O., Mitchell, S., & Connelly, S. (2020). Zero trust architecture (NIST SP 800-207). National Institute of Standards and Technology. https://doi.org/10.6028/NIST.SP.800-207

Office of Management and Budget. (2026, January 23). M-26-05: Adopting a risk-based approach to software and hardware security. https://www.whitehouse.gov/wp-content/uploads/2026/01/M-26-05-Adopting-a-Risk-based-Approach-to-Software-and-Hardware-Security.pdf

Office of Management and Budget. (2025, April 3). M-25-21: Accelerating federal use of AI through innovation, governance, and public trust. https://www.whitehouse.gov/wp-content/uploads/2025/04/M-25-21.pdf

Office of Management and Budget. (2025, April 3). M-25-22: Driving efficient acquisition of artificial intelligence in government. https://www.whitehouse.gov/wp-content/uploads/2025/04/M-25-22.pdf

Office of Management and Budget. (2016, August 8). M-16-21: Federal source code policy. https://obamawhitehouse.archives.gov/sites/default/files/omb/memoranda/2016/m_16_21.pdf

Office of Management and Budget. (2022, September 14). M-22-18: Enhancing the security of the software supply chain through secure software development practices. Note: Rescinded by OMB M-26-05 (January 2026). https://www.whitehouse.gov/wp-content/uploads/2022/09/M-22-18.pdf

OpenTelemetry Project. (2024). OpenTelemetry specification and SDK documentation. https://opentelemetry.io/docs/

OWASP Foundation. (2024). OWASP top 10 for large language model applications, Version 2025. https://owasp.org/www-project-top-10-for-large-language-model-applications/

© 2026 Aptive Resources  •  All rights reserved
The latest document management technologies in action, featurin

The Series

Article 1 puts the series in federal governance context. Article 2 gets into operational maturity: what a production-ready agentic AI program actually looks like day to day. After that, we’ll cover the technical core, built for delivery architects, DevSecOps leads and ATO teams, with each article building on the previous one.

Web Agentic AI. v1.indd6

1. NIST AI RMF 1.0 Alignment Analysis: Agentic AI Governance for Federal Programs

Coverage assessment mapping the series to all four AI RMF functions and naming residual gaps

 

PUBLISHED: August 18, 2026
Read More
Web Agentic AI. v1.indd7

2. Advanced Operational Maturity for Multi-Agent AI Systems

KPI baselines, model risk lifecycle, data lineage, continuous assurance and ATO evidence packaging

 

PUBLISHED: AUGUST 18, 2026
Read More
Web Agentic AI. v1.indd5

3. Organizational AI Governance: Frameworks, Artifacts and Implementation Guidance

The nine artifacts a defensible AI program needs, from risk tolerance through incident response

 

PUBLISHED: AUGUST 25, 2026
Read More
Web Agentic AI. v1.indd4

4. Multi-Model and Multi-Agent AI Systems: Infrastructure Implementation Guide

The security infrastructure behind the policy, from sandboxed code execution to a CISA-aligned 72-hour AI incident response plan

 

PUBLISHED: SEPTEMBER 1, 2026
4. Multi-Model and Multi-Agent AI Systems: Infrastructure Implementation Guide
Web Agentic AI. v1.indd3

5. The Orchestrator Capability Manifest: Governing Tool Access, Prompt Integrity and Model Authorization in Multi-Agent AI Systems

Structured governance artifact defining agent roles, tool grants, prompt versioning and model pinning

 

Release Date: September 8, 2026
Web Agentic AI. v1.indd2

6. Multi-Model and Multi-Agent AI Workflows: Architecture, Risk and DevSecOps Controls

Trust boundaries, interagent messaging controls, human-in-the-loop gate design and authorization

 

Release Date: September 15, 2026
Web Agentic AI. v1.indd

7. Model Context Protocol (MCP) Servers in Enterprise AI Architecture

Security architecture, supply chain controls and NIST 800-53 mapping for self-hosted MCP servers

 

Release Date: September 22, 2026