Reading
Agentic Control Plane is a control plane built for AI Agent systems. It leverages Terraform's plan/apply workflow and Kubernetes' resource model, using declarative YAML to manage agents, tools, workflows, and policies, enabling version-controlled, auditable, and observable Agent operations.
Section 01
Agentic Control Plane is a control plane built for AI Agent systems. It leverages Terraform's plan/apply workflow and Kubernetes' resource model, using declarative YAML to manage agents, tools, workflows, and policies, enabling version-controlled, auditable, and observable Agent operations.
Section 02
With the rapid development of AI Agent technology, more and more teams are building complex Agent systems. However, current Agent frameworks generally have a fundamental problem: configuration and logic are deeply coupled in application code. Key configurations such as prompts, tool bindings, and permission controls are buried deep in the code, making it difficult for teams to answer basic operational questions:
This "black-box" Agent development runs counter to DevOps best practices. In the infrastructure field, Terraform solved similar problems through declarative configuration and the plan/apply workflow. Now, Agentic Control Plane introduces this concept to the AI Agent domain.
Agentic Control Plane has a clear positioning: This is not another opaque Agent framework, but a control plane. It draws on core ideas from multiple mature technologies:
| Concept | Analogous Technology |
|---|---|
| Desired Resources in Git | GitOps |
| plan/apply/drift detection | Terraform |
| Typed Resources (Project, Workflow, Policy, etc.) | Kubernetes-style API |
| Tools and IO Contracts | OpenAPI-style explicit definition |
By integrating these ideas, Agentic Control Plane achieves:
Agentic Control Plane uses a layered architecture with core components including:
All configurations are expressed in YAML and support version control. Main resource types include:
agentctl is the main interaction interface, providing full lifecycle management:
agentctl init: Scaffolds project.yaml, policies, tools, and sample workflowsagentctl validate: Loads the project, applies defaults/environment overrides, validates graphs, schemas, and referencesagentctl plan: Compares the desired graph with SQLite deployment state, provides risk promptsagentctl apply: Persists the plan (supports TTY confirmation or --auto-approve)agentctl run: Executes workflows locally, supports JSON Schema input validation and policy gatingagentctl logs: Reads tracking events from SQLiteState is stored by default in the .agentic/state.db SQLite file in the project root directory, including:
This design ensures data sovereignty and offline work capability, while supporting storage location override via the --state parameter.
Installing Agentic Control Plane is simple, supporting source code build or precompiled binary download:
git clone https://github.com/LAA-Software-Engineering/agentic-control-plane.git
cd agentic-control-plane
make build # Generates bin/agentctl
GitHub Releases provides multi-platform binaries (Linux, macOS, Windows). Download the compressed package for your platform and extract it to PATH.
# Initialize the project
agentctl init my-agent-system
# Validate configuration
agentctl validate --project my-agent-system
# Generate execution plan
agentctl plan --project my-agent-system
# Apply configuration
agentctl apply --project my-agent-system --auto-approve
# Run workflow
agentctl run workflow/hello --project my-agent-system
# View logs
agentctl logs --project my-agent-system --workflow hello
The initialized project.yaml shows the core configuration structure:
apiVersion: agentic.dev/v0
kind: Project
metadata:
name: my-agent-system
spec:
imports:
- ./policies/default.yaml
- ./tools/helper.yaml
- ./workflows/hello.yaml
defaults:
policy: default
model: openai/gpt-4o-mini
providers:
models:
openai:
type: openai
apiKeyFrom: env:OPENAI_API_KEY
# anthropic:
# type: anthropic
# apiKeyFrom: env:ANTHROPIC_API_KEY
This structure clearly separates resource definitions, environment configurations, and provider settings, supporting multi-environment management and external storage of sensitive information.
Agentic Control Plane has a built-in policy engine that enforces multiple rules during execution:
Limits resource consumption (e.g., API call count, token usage) for a single run or time window.
Fine-grained control over which workflows can use which tools to prevent unauthorized tool calls.
Implements manual or automatic approval for high-risk operations (e.g., tool calls involving sensitive data).
All executions are recorded as structured traces, supporting post-audit and compliance checks.
The project provides full observability support:
All runs generate detailed trace records, including:
Automatically clean up old data via spec.traces.retentionDays configuration to balance storage costs and audit needs.
The CLI supports three output formats: table, JSON, YAML, facilitating script integration and human reading.
| Feature | Agentic Control Plane | Traditional Agent Frameworks |
|---|---|---|
| Configuration Method | Declarative YAML | Embedded in Code |
| Version Control | Natively Supported | Requires Extra Work |
| Change Review | Plan/Apply Workflow | Usually Not Supported |
| Policy Execution | Built-in Policy Engine | Requires Custom Implementation |
| Observability | Structured Traces | Depends on External Tools |
| State Management | Local SQLite | Usually Stateless |
Agentic Control Plane is suitable for multiple scenarios:
Enterprise environments requiring strict change management, audit tracking, and policy compliance.
Separation and synchronization of configurations across development, testing, and production environments.
Configuration review and version control via Git workflows.
Meeting the auditability requirements of AI systems in industries like finance and healthcare.
The project is developed in Go with a clear code structure:
cmd/agentctl: CLI entry pointinternal/cli: Cobra commands, flags, golden testsinternal/spec: YAML types, normalization, validationinternal/project: Project loading and import parsinginternal/plan: Plan generation and risk summaryinternal/apply: Plan application to deployment storageinternal/engine: Workflow execution engineinternal/policy: Policy evaluationinternal/state/sqlite: SQLite deployment and runtime/trace tablesThis modular design facilitates expansion and maintenance, and provides clear access points for community contributions.
Agentic Control Plane represents a new paradigm for Agent system management: introducing operational best practices from the infrastructure domain to the AI field. Through declarative configuration, version control, policy enforcement, and observability, it provides teams with a complete set of Agent lifecycle management tools.
The current version (v0.1.x) has implemented core features, including a full CLI workflow, SQLite state management, policy engine, and structured tracing. The future roadmap includes remote control plane, richer policy types, and broader tool ecosystem integration.
For teams building production-grade Agent systems, Agentic Control Plane provides a pragmatic and implementable governance solution worth exploring in depth.
Section 03
Agentic Control Plane: Managing AI Agent Systems in a Terraform-Style
Background: Operational Challenges of Agent Systems
With the rapid development of AI Agent technology, more and more teams are building complex Agent systems. However, current Agent frameworks generally have a fundamental problem: configuration and logic are deeply coupled in application code. Key configurations such as prompts, tool bindings, and permission controls are buried deep in the code, making it difficult for teams to answer basic operational questions:
This "black-box" Agent development runs counter to DevOps best practices. In the infrastructure field, Terraform solved similar problems through declarative configuration and the plan/apply workflow. Now, Agentic Control Plane introduces this concept to the AI Agent domain.
Core Design Philosophy
Agentic Control Plane has a clear positioning: This is not another opaque Agent framework, but a control plane. It draws on core ideas from multiple mature technologies:
| Concept | Analogous Technology |
|---|---|
| Desired Resources in Git | GitOps |
| plan/apply/drift detection | Terraform |
| Typed Resources (Project, Workflow, Policy, etc.) | Kubernetes-style API |
| Tools and IO Contracts | OpenAPI-style explicit definition |
By integrating these ideas, Agentic Control Plane achieves:
Architecture Overview
Agentic Control Plane uses a layered architecture with core components including:
All configurations are expressed in YAML and support version control. Main resource types include:
agentctl is the main interaction interface, providing full lifecycle management:
agentctl init: Scaffolds project.yaml, policies, tools, and sample workflowsagentctl validate: Loads the project, applies defaults/environment overrides, validates graphs, schemas, and referencesagentctl plan: Compares the desired graph with SQLite deployment state, provides risk promptsagentctl apply: Persists the plan (supports TTY confirmation or --auto-approve)agentctl run: Executes workflows locally, supports JSON Schema input validation and policy gatingagentctl logs: Reads tracking events from SQLiteState is stored by default in the .agentic/state.db SQLite file in the project root directory, including:
This design ensures data sovereignty and offline work capability, while supporting storage location override via the --state parameter.
Quick Start
Installing Agentic Control Plane is simple, supporting source code build or precompiled binary download:
Build from Source
git clone https://github.com/LAA-Software-Engineering/agentic-control-plane.git
cd agentic-control-plane
make build # Generates bin/agentctl
Use Precompiled Binaries
GitHub Releases provides multi-platform binaries (Linux, macOS, Windows). Download the compressed package for your platform and extract it to PATH.
Basic Workflow
# Initialize the project
agentctl init my-agent-system
# Validate configuration
agentctl validate --project my-agent-system
# Generate execution plan
agentctl plan --project my-agent-system
# Apply configuration
agentctl apply --project my-agent-system --auto-approve
# Run workflow
agentctl run workflow/hello --project my-agent-system
# View logs
agentctl logs --project my-agent-system --workflow hello
Configuration Example
The initialized project.yaml shows the core configuration structure:
apiVersion: agentic.dev/v0
kind: Project
metadata:
name: my-agent-system
spec:
imports:
- ./policies/default.yaml
- ./tools/helper.yaml
- ./workflows/hello.yaml
defaults:
policy: default
model: openai/gpt-4o-mini
providers:
models:
openai:
type: openai
apiKeyFrom: env:OPENAI_API_KEY
anthropic:
type: anthropic
apiKeyFrom: env:ANTHROPIC_API_KEY
This structure clearly separates resource definitions, environment configurations, and provider settings, supporting multi-environment management and external storage of sensitive information.
Policy and Governance
Agentic Control Plane has a built-in policy engine that enforces multiple rules during execution:
Budget Control Limits resource consumption (e.g., API call count, token usage) for a single run or time window.
Tool Permissions Fine-grained control over which workflows can use which tools to prevent unauthorized tool calls.
Approval Workflow Implements manual or automatic approval for high-risk operations (e.g., tool calls involving sensitive data).
Audit Tracking All executions are recorded as structured traces, supporting post-audit and compliance checks.
Observability and Debugging
The project provides full observability support:
Structured Logs All runs generate detailed trace records, including:
Data Retention
Automatically clean up old data via spec.traces.retentionDays configuration to balance storage costs and audit needs.
Multi-Format Output The CLI supports three output formats: table, JSON, YAML, facilitating script integration and human reading.
Comparison with Existing Solutions
| Feature | Agentic Control Plane | Traditional Agent Frameworks |
|---|---|---|
| Configuration Method | Declarative YAML | Embedded in Code |
| Version Control | Natively Supported | Requires Extra Work |
| Change Review | Plan/Apply Workflow | Usually Not Supported |
| Policy Execution | Built-in Policy Engine | Requires Custom Implementation |
| Observability | Structured Traces | Depends on External Tools |
| State Management | Local SQLite | Usually Stateless |
Practical Application Scenarios
Agentic Control Plane is suitable for multiple scenarios:
Enterprise-Level Agent Deployment Enterprise environments requiring strict change management, audit tracking, and policy compliance.
Multi-Environment Management Separation and synchronization of configurations across development, testing, and production environments.
Team Collaboration Configuration review and version control via Git workflows.
Compliance Requirements Meeting the auditability requirements of AI systems in industries like finance and healthcare.
Technical Implementation Details
The project is developed in Go with a clear code structure:
cmd/agentctl: CLI entry pointinternal/cli: Cobra commands, flags, golden testsinternal/spec: YAML types, normalization, validationinternal/project: Project loading and import parsinginternal/plan: Plan generation and risk summaryinternal/apply: Plan application to deployment storageinternal/engine: Workflow execution engineinternal/policy: Policy evaluationinternal/state/sqlite: SQLite deployment and runtime/trace tablesThis modular design facilitates expansion and maintenance, and provides clear access points for community contributions.
Summary and Outlook
Agentic Control Plane represents a new paradigm for Agent system management: introducing operational best practices from the infrastructure domain to the AI field. Through declarative configuration, version control, policy enforcement, and observability, it provides teams with a complete set of Agent lifecycle management tools.
The current version (v0.1.x) has implemented core features, including a full CLI workflow, SQLite state management, policy engine, and structured tracing. The future roadmap includes remote control plane, richer policy types, and broader tool ecosystem integration.
For teams building production-grade Agent systems, Agentic Control Plane provides a pragmatic and implementable governance solution worth exploring in depth.
Keep going with more reads from the same topic.
Nornir MCP Server is an enterprise-level server based on the Model Context Protocol (MCP). It seamlessly integrates large language models (such as Claude) with the Nornir network automation framework, supporting natural language orchestration for multi-vendor network devices (Cisco, Arista, Juniper, etc.), and providing production-grade features like a dual-engine architecture (NAPALM + Netmiko), intelligent filtering, and a secure sandbox.
Bibliothèque Française LLM is a structured indexing and annotation project for French public domain literature designed specifically for large language models (LLMs). It integrates multiple authoritative sources such as DraCor, Common Corpus, and Wikisource, providing metadata indexing categorized by genre, author, and era, as well as in-depth annotations for dramatic texts (including characters, lines, stage directions, etc.). Its aim is to enable LLMs to efficiently read and understand classic French literary works.
Splinter is a minimalist, high-performance key-value (KV) and vector storage system enabling zero-latency inter-process communication via shared memory and atomic operations. With only 766 lines of core code, it supports millions of operations per second and 768-dimensional vector storage, offering a new architectural approach for local LLM inference and data-intensive applications.
libmlxforge is an embeddable MLX large language model (LLM) inference engine designed specifically for Apple Silicon. It provides a unified C ABI interface, supports calls from Node.js, Swift, and Rust, and features continuous batching, streaming output, JSON-constrained structured output, and embedding vector generation.