Current State, Roadmap, and Ecosystem Fit

Version Status

Both the AOS and ACS repositories publish the same staged roadmap:

v0.1 (Public Preview) — Current Stage

• Documentation — comprehensive guides and reference materials
• Definitions/Schema — hook specifications, event schemas, verdict objects
• OpenTelemetry/OCSF Observability Definitions — agent-specific semantic conventions
• AgBOM Requirements — specifications for dynamic component inventory

v1 — Planned

• Reference Guardian Agent Implementation — production-ready enforcement engine
• AOS/ACS-to-OpenTelemetry Mapper — standard integration components
• AOS/ACS-to-OCSF Mapper — security event conversion tools
• FastMCP Client Instrumentation — Model Context Protocol integration
• A2A Client Instrumentation — Agent-to-Agent protocol integration

v2 — Planned

• Full CycloneDX Requirements — complete AgBOM specification for CycloneDX
• Full SPDX Requirements — complete AgBOM specification for SPDX
• Full SWID Requirements — complete AgBOM specification for SWID
• Mapper Implementations — automated AgBOM generation and management tools

v3 — Planned

• MCP Protocol Extensions — native deny/modify operations in MCP itself
• A2A Protocol Extensions — native deny/modify operations in A2A itself
• Protocol-Level Control — move from external gating to protocol-native enforcement

Active Workstreams

Per the ACS site and launch coverage, several workstreams are actively progressing:

Middleware/Guardian Agent Reference Implementation

• Status: Active
• Focus: Production-ready Guardian Agent implementation
• Goal: Provide a reference implementation that organizations can deploy or adapt

OpenTelemetry Upstream Contribution

• Status: Active
• Focus: Contributing agent-specific semantic conventions to OpenTelemetry
• Goal: Make agent observability a standard part of the OpenTelemetry ecosystem

AgBOM Extensions to CycloneDX/SPDX

• Status: In Progress
• Focus: Extending existing BOM standards for agent-specific requirements
• Goal: Enable agent component tracking using industry-standard formats

MCP/A2A Protocol Integration

• Status: Planned
• Focus: Deep integration with Model Context Protocol and Agent-to-Agent protocol
• Goal: Native protocol-level support for ACS controls

Identity Workstream

• Status: Announced
• Focus: Non-human agent authentication, ephemeral credentials, just-in-time access
• Goal: Solve the agent identity and privilege management challenge

Coding-Agent Workstream

• Status: Announced
• Focus: Extending ACS hooks to IDE-based agents
• Goal: Apply ACS controls to code generation, file edits, command execution

Ecosystem Fit

ACS explicitly builds on rather than competes with adjacent standards:

Integration Philosophy

ACS follows a complement, not replace philosophy:

• Builds on existing standards — leverages OpenTelemetry, OCSF, CycloneDX, SPDX, SWID
• Extends rather than invents — adds agent-specific capabilities to proven frameworks
• Interoperates by design — works with existing security and observability infrastructure
• Community-driven — contributes upstream rather than creating parallel ecosystems

Current Adoption Status

A Snapshot, Not a Verdict

As of this writing (July 2026):

• OWASP AOS Repository: ~53 stars, ~31 forks
• ACS Repository: ~37 stars, ~9 forks

Important Context:

• Both numbers will be stale by the time you read this
• Check the repositories directly for current activity, open issues, and framework support
• Early adoption numbers don’t reflect production readiness or long-term viability
• Public-preview status means active development and rapid evolution

Framework Support Matrix

Check the current framework-support matrix before assuming your stack is covered:

• Native hook support — some frameworks have first-class AOS integration
• Wrapper-based integration — some frameworks require manual wrapper integration
• No current support — some frameworks may not yet have AOS integration

Recommendation: Verify current support for your specific frameworks before planning implementation.

Community and Governance

Project Governance

Both AOS and ACS are community-governed:

• No single vendor ownership — Zenity is a lead contributor and sponsor, not the owner
• Open-source licenses — Apache 2.0 for AOS, MIT for ACS
• Community contributions — accept contributions from the broader community
• Transparent development — issues, discussions, and roadmap are public

Contributing

Ways to contribute to the ACS/AOS ecosystem:

• Implementation feedback — share lessons from production deployments
• Issue reports — report bugs or gaps in the specification
• Feature requests - propose new capabilities or improvements
• Documentation — improve guides and reference materials
• Code contributions — submit implementations or integrations

Community Resources

Engage with the ACS/AOS community:

• GitHub repositories — issues, discussions, pull requests
• ACS site — agentcontrolstandard.org
• AOS site — aos.owasp.org
• OWASP community — participate in OWASP GenAI Security Project
• Conferences and events — AI Agent Security Summit and other industry events

Production Readiness Considerations

Public-Preview Status

ACS is currently in public-preview (v0.1.x), which means:

• Actively evolving — specifications and implementations may change
• Limited production case studies — few large-scale enterprise deployments documented
• Rapid iteration — frequent updates based on community feedback
• Breaking changes possible — later versions may include breaking changes

Evaluation Before Adoption

Before committing to ACS for production use:

1. Check current framework support — verify your stack has native or wrapper-based integration
2. Review issue backlog — understand known limitations and planned fixes
3. Evaluate reference implementations — assess if they meet your requirements
4. Plan for evolution — consider how you’ll handle specification changes
5. Engage with the community — understand the roadmap and contribute feedback

Complement, Not Replace

Consider ACS as part of a broader guardrails strategy:

• Combine with other controls — use ACS alongside existing security measures
• Defense in depth — layer ACS with other security controls for robust protection
• Gradual adoption — start with non-critical agents and expand coverage over time
• Continuous evaluation — assess effectiveness and adjust your approach as needed

Key Takeaways

1. Staged roadmap — clear path from public preview to protocol-level controls
2. Active development — multiple workstreams progressing in parallel
3. Ecosystem integration — builds on existing standards rather than competing
4. Early adoption stage — limited production case studies, active evolution
5. Community governance — no single vendor ownership, open-source licenses
6. Evaluate before committing — assess framework support and production readiness
7. Part of broader strategy — use ACS as part of a defense-in-depth approach

Next Steps

• Limitations & Critique — understand the current constraints and critical perspectives
• Key Resources — access official documentation and community links