agenticops-control-tower 0.0.1__py3-none-any.whl

agenticops_control_tower/__init__.py

@@ -0,0 +1,5 @@
+"""Scaffold package for the DeepAgentLabs control plane."""
+
+__all__ = ["__version__"]
+
+__version__ = "0.0.1"

agenticops_control_tower/adapters/__init__.py

@@ -0,0 +1,5 @@
+"""Thin ecosystem adapter placeholders."""
+
+from .catalog import ADAPTER_NAMES
+
+__all__ = ["ADAPTER_NAMES"]

agenticops_control_tower/adapters/catalog.py

@@ -0,0 +1,8 @@
+"""Named adapter placeholders for sibling projects."""
+
+ADAPTER_NAMES = (
+    "agenticlens",
+    "agentic-sidecar",
+    "agentic-chaos",
+    "deep-agentic-core-mcp",
+)

agenticops_control_tower/api/__init__.py

@@ -0,0 +1,5 @@
+"""Control-plane API placeholders."""
+
+from .surface import ControlTowerAPI
+
+__all__ = ["ControlTowerAPI"]

agenticops_control_tower/api/surface.py

@@ -0,0 +1,28 @@
+"""Read-only scaffold API over the registry."""
+
+from __future__ import annotations
+
+from agenticops_control_tower.discovery import CapabilityDiscoveryService
+from agenticops_control_tower.models import AgentRecord
+from agenticops_control_tower.registry import AgentRegistry
+
+
+class ControlTowerAPI:
+    """Small facade that mirrors the v0.1 roadmap surface."""
+
+    def __init__(
+        self,
+        registry: AgentRegistry,
+        discovery: CapabilityDiscoveryService,
+    ) -> None:
+        self._registry = registry
+        self._discovery = discovery
+
+    def list_agents(self) -> list[AgentRecord]:
+        return self._registry.list_agents()
+
+    def get_agent(self, agent_id: str) -> AgentRecord:
+        return self._registry.get(agent_id)
+
+    def list_capabilities(self, agent_id: str) -> dict[str, str]:
+        return self._discovery.list_capabilities(self._registry.get(agent_id))

agenticops_control_tower/cli/__init__.py

@@ -0,0 +1 @@
+"""CLI placeholders."""

agenticops_control_tower/cli/main.py

@@ -0,0 +1,11 @@
+"""Placeholder CLI entry module.
+
+No console script is published yet. This module exists so the scaffold already
+has a stable home for future commands.
+"""
+
+
+def main() -> str:
+    """Return a short scaffold message for direct import-based smoke tests."""
+
+    return "agenticops-control-tower CLI scaffold"

agenticops_control_tower/config/__init__.py

@@ -0,0 +1,5 @@
+"""Configuration placeholders."""
+
+from .models import ConfigPatch, ConfigScope
+
+__all__ = ["ConfigPatch", "ConfigScope"]

agenticops_control_tower/config/models.py

@@ -0,0 +1,19 @@
+"""Future-facing configuration models kept intentionally small."""
+
+from __future__ import annotations
+
+from pydantic import BaseModel, Field
+
+
+class ConfigScope(BaseModel):
+    """Target scope for a future centralized config operation."""
+
+    agent_id: str | None = None
+    environment: str | None = None
+    capability: str | None = None
+
+
+class ConfigPatch(BaseModel):
+    """Opaque patch payload for the scaffold stage."""
+
+    values: dict[str, object] = Field(default_factory=dict)

agenticops_control_tower/console/__init__.py

@@ -0,0 +1 @@
+"""Web console placeholders."""

agenticops_control_tower/console/app.py

@@ -0,0 +1,7 @@
+"""Console placeholder surface."""
+
+
+def console_status() -> str:
+    """Return a scaffold-only status string."""
+
+    return "AgenticOps Console scaffold"

agenticops_control_tower/discovery/__init__.py

@@ -0,0 +1,5 @@
+"""Capability discovery placeholders."""
+
+from .service import CapabilityDiscoveryService
+
+__all__ = ["CapabilityDiscoveryService"]

agenticops_control_tower/discovery/service.py

@@ -0,0 +1,17 @@
+"""Capability discovery scaffold.
+
+The real implementation will likely combine explicit agent-reported metadata
+with adapter-assisted discovery. For now this module only exposes a normalized
+view over an agent's reported capabilities.
+"""
+
+from __future__ import annotations
+
+from agenticops_control_tower.models import AgentRecord
+
+
+class CapabilityDiscoveryService:
+    """Scaffold normalization for capability inventory."""
+
+    def list_capabilities(self, agent: AgentRecord) -> dict[str, str]:
+        return dict(sorted(agent.capabilities.items()))

agenticops_control_tower/models/__init__.py

@@ -0,0 +1,5 @@
+"""Core models shared across scaffold modules."""
+
+from .agent import AgentRecord, AgentStatus, HeartbeatPayload
+
+__all__ = ["AgentRecord", "AgentStatus", "HeartbeatPayload"]

agenticops_control_tower/models/agent.py

@@ -0,0 +1,38 @@
+"""Minimal agent inventory models for the scaffold stage."""
+
+from __future__ import annotations
+
+from datetime import datetime, timezone
+from enum import Enum
+
+from pydantic import BaseModel, Field
+
+
+class AgentStatus(str, Enum):
+    """High-level health states for the initial registry model."""
+
+    HEALTHY = "healthy"
+    DEGRADED = "degraded"
+    UNHEALTHY = "unhealthy"
+    UNKNOWN = "unknown"
+
+
+class HeartbeatPayload(BaseModel):
+    """Runtime-reported status snapshot for a registered agent."""
+
+    status: AgentStatus = AgentStatus.UNKNOWN
+    last_seen: datetime = Field(default_factory=lambda: datetime.now(timezone.utc))
+    capabilities: dict[str, str] = Field(default_factory=dict)
+
+
+class AgentRecord(BaseModel):
+    """Inventory record for one known agent."""
+
+    agent_id: str
+    name: str
+    environment: str
+    runtime: str
+    framework: str
+    status: AgentStatus = AgentStatus.UNKNOWN
+    capabilities: dict[str, str] = Field(default_factory=dict)
+    last_seen: datetime | None = None

agenticops_control_tower/registry/__init__.py

@@ -0,0 +1,5 @@
+"""Agent registry primitives."""
+
+from .service import AgentRegistry
+
+__all__ = ["AgentRegistry"]

agenticops_control_tower/registry/service.py

@@ -0,0 +1,29 @@
+"""In-memory scaffold for registration and heartbeat flows."""
+
+from __future__ import annotations
+
+from agenticops_control_tower.models import AgentRecord, HeartbeatPayload
+
+
+class AgentRegistry:
+    """Very small in-memory registry to anchor the scaffold tests."""
+
+    def __init__(self) -> None:
+        self._agents: dict[str, AgentRecord] = {}
+
+    def register(self, agent: AgentRecord) -> AgentRecord:
+        self._agents[agent.agent_id] = agent
+        return agent
+
+    def heartbeat(self, agent_id: str, heartbeat: HeartbeatPayload) -> AgentRecord:
+        agent = self._agents[agent_id]
+        agent.status = heartbeat.status
+        agent.last_seen = heartbeat.last_seen
+        agent.capabilities = heartbeat.capabilities
+        return agent
+
+    def list_agents(self) -> list[AgentRecord]:
+        return list(self._agents.values())
+
+    def get(self, agent_id: str) -> AgentRecord:
+        return self._agents[agent_id]

agenticops_control_tower-0.0.1.dist-info/METADATA

@@ -0,0 +1,299 @@
+Metadata-Version: 2.5
+Name: agenticops-control-tower
+Version: 0.0.1
+Summary: Unified control plane and operations console for the DeepAgentLabs ecosystem.
+Project-URL: Homepage, https://github.com/DeepAgentLabs/agenticops-control-tower
+Project-URL: Repository, https://github.com/DeepAgentLabs/agenticops-control-tower
+Project-URL: Issues, https://github.com/DeepAgentLabs/agenticops-control-tower/issues
+Project-URL: Changelog, https://github.com/DeepAgentLabs/agenticops-control-tower/blob/main/CHANGELOG.md
+Author: agenticops-control-tower Contributors
+License: MIT License
+        
+        Copyright (c) 2026 agenticops-control-tower Contributors
+        
+        Permission is hereby granted, free of charge, to any person obtaining a copy
+        of this software and associated documentation files (the "Software"), to deal
+        in the Software without restriction, including without limitation the rights
+        to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+        copies of the Software, and to permit persons to whom the Software is
+        furnished to do so, subject to the following conditions:
+        
+        The above copyright notice and this permission notice shall be included in all
+        copies or substantial portions of the Software.
+        
+        THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+        IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+        FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+        AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+        LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+        OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+        SOFTWARE.
+        
+License-File: LICENSE
+Keywords: agents,chaos,control-plane,governance,observability,operations
+Classifier: Development Status :: 2 - Pre-Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.10
+Requires-Dist: pydantic<3,>=2.0
+Provides-Extra: agentic-chaos
+Requires-Dist: agentic-chaos>=0.1; extra == 'agentic-chaos'
+Provides-Extra: agentic-sidecar
+Requires-Dist: agentic-sidecar>=0.0.1; extra == 'agentic-sidecar'
+Provides-Extra: agenticlens
+Requires-Dist: agenticlens>=0.1.3; extra == 'agenticlens'
+Provides-Extra: deep-agentic-core-mcp
+Requires-Dist: deep-agentic-core-mcp>=0.2.0; extra == 'deep-agentic-core-mcp'
+Provides-Extra: dev
+Requires-Dist: build>=1.2; extra == 'dev'
+Requires-Dist: mypy>=1.10; extra == 'dev'
+Requires-Dist: pytest-cov>=5.0; extra == 'dev'
+Requires-Dist: pytest>=8.0; extra == 'dev'
+Requires-Dist: ruff>=0.6; extra == 'dev'
+Requires-Dist: twine>=5.1; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# agenticops-control-tower
+
+**A unified control plane and operations console for the DeepAgentLabs ecosystem.**
+
+> AgenticLens observes. Agentic Sidecar governs. Agentic Chaos tests. Agentic
+> MCP connects. Control Tower operates.
+
+## Status
+
+**Concept / pre-implementation.** This repository currently contains the
+architecture proposal ([`DeepAgent Control Tower End-to-End Concept.md`](DeepAgent%20Control%20Tower%20End-to-End%20Concept.md)),
+this README, and the build plan in [ROADMAP.md](ROADMAP.md).
+
+There is **no package code, no PyPI release, no API server, no CLI, and no web
+console yet**. The point of the project today is to define the control-plane
+shape clearly enough that implementation can start in a narrow, believable
+order.
+
+## Contents
+
+- [Why this exists](#why-this-exists)
+- [What Control Tower is](#what-control-tower-is)
+- [What it is not](#what-it-is-not)
+- [Architecture](#architecture)
+- [Control Tower surfaces](#control-tower-surfaces)
+- [Human operators and AI operators](#human-operators-and-ai-operators)
+- [Runtime and framework position](#runtime-and-framework-position)
+- [The DeepAgentLabs ecosystem](#the-deepagentlabs-ecosystem)
+- [Initial scope](#initial-scope)
+- [Roadmap](#roadmap)
+
+## Why this exists
+
+The DeepAgentLabs projects each answer a different operational question:
+
+- **AgenticLens** asks: what happened, why did it happen, and what should I fix?
+- **Agentic Sidecar** asks: should this action happen right now, given the
+  user's intent and current risk?
+- **Agentic Chaos** asks: what breaks under stress, failure, and silent
+  degradation?
+- **Agentic MCP** asks: how do hosts and agents access these capabilities
+  through one MCP-native surface?
+
+What is still missing is the layer above them:
+
+> What is deployed, where is it running, which capabilities are enabled, what
+> is unhealthy, and how do I operate all of it from one place?
+
+That missing layer is the job of `agenticops-control-tower`.
+
+## What Control Tower is
+
+Control Tower is intended to be the **runtime-agnostic, framework-agnostic
+operations layer** for teams running multiple agents and multiple
+DeepAgentLabs capabilities.
+
+At a high level, it should eventually provide:
+
+- a central agent registry
+- capability discovery across agents and environments
+- health and status visibility
+- centralized configuration for supported capabilities
+- a unified control API
+- a human CLI
+- a web console for operators
+
+The key distinction is that Control Tower is **not just a dashboard**. The
+dashboard is only one interface to the underlying control plane.
+
+## What it is not
+
+- **Not a replacement for AgenticLens.** Control Tower may surface Lens
+  insights, but Lens remains the observability and evaluation engine.
+- **Not a replacement for Agentic Sidecar.** Control Tower may surface
+  Sidecar decisions and governance posture, but Sidecar remains the
+  decision-time supervision layer.
+- **Not a replacement for Agentic Chaos.** Control Tower may orchestrate or
+  summarize chaos posture, but Chaos remains the resilience-testing engine.
+- **Not the MCP layer itself.** Agentic MCP remains an independent package
+  and should be able to connect both to individual DeepAgentLabs capabilities
+  and to Control Tower.
+- **Not tied to one runtime or one framework.** The control plane should sit
+  above LangGraph, CrewAI, AutoGen, OpenAI Agents SDK, AWS AgentCore-style
+  workloads, MCP-native agents, and custom Python systems rather than
+  assuming one execution model.
+- **Not implemented yet.** The architecture in the concept doc is broader
+  than what a first real release should attempt. See [ROADMAP.md](ROADMAP.md)
+  for the narrowed build order.
+
+## Architecture
+
+The ecosystem boundary should stay crisp:
+
+```text
+Control Tower = OPERATE
+Agentic MCP   = CONNECT
+AgenticLens   = OBSERVE
+Agentic Sidecar = GOVERN
+Agentic Chaos = TEST
+AI Operations Specification = STANDARDIZE
+```
+
+Conceptually:
+
+```text
+                   Human operators           AI operators
+                          |                       |
+                  Console / CLI / API        Agentic MCP
+                          |                       |
+                          +-----------+-----------+
+                                      |
+                                      v
+                         DeepAgent Control Tower
+                                      |
+                   +------------------+------------------+
+                   |                  |                  |
+                   v                  v                  v
+              AgenticLens      Agentic Sidecar     Agentic Chaos
+```
+
+Control Tower's role is to centralize operations across agents and
+capabilities, not to absorb the implementation logic of the sibling projects.
+
+## Control Tower surfaces
+
+The concept doc points to five main product surfaces:
+
+- **Agent Registry**: inventory of known agents, runtimes, frameworks,
+  environments, capability versions, and last-seen status
+- **Capability Discovery**: detect which DeepAgentLabs packages and features
+  are present on each agent wherever automatic discovery is technically
+  feasible
+- **Configuration**: centralized configuration and policy updates for
+  supported capabilities
+- **Unified Control API**: one programmatic interface over inventory, health,
+  capability status, and supported operations
+- **AgenticOps Console**: the human-facing dashboard over the same control
+  plane used by the API and CLI
+
+The CLI should be a first-class interface, not an afterthought. The same is
+true for AI-facing operation through Agentic MCP once the underlying control
+API exists.
+
+## Human operators and AI operators
+
+This project is unusual in that it has two equally important operator models:
+
+- **Humans** should be able to use a console, CLI, or API to inspect and
+  operate agents across environments.
+- **AI systems** should be able to use Agentic MCP to inspect and operate the
+  same control plane through an MCP-native interface.
+
+That separation matters:
+
+- Control Tower does **not** require MCP
+- MCP does **not** require Control Tower
+- when used together, MCP becomes the AI-native interface to the control
+  plane
+
+## Runtime and framework position
+
+Control Tower should be:
+
+- **runtime agnostic**: local Python, containers, VMs, Kubernetes,
+  serverless, cloud-specific runtimes, and on-prem systems are all valid
+  targets
+- **framework agnostic**: LangGraph, CrewAI, AutoGen, OpenAI Agents SDK,
+  custom harnesses, MCP-based agents, and future frameworks should all fit
+  the model
+- **modular**: teams should be able to adopt a single DeepAgentLabs
+  capability without adopting the entire stack
+
+That means deployment packaging is an implementation choice, not an
+architectural dependency.
+
+## The DeepAgentLabs ecosystem
+
+Control Tower only makes sense if the package boundaries stay clear:
+
+| Project | Role |
+| --- | --- |
+| `agenticlens` | Observe |
+| `agentic-sidecar` | Govern |
+| `agentic-chaos` | Test |
+| `deep-agentic-core-mcp` | Connect |
+| `ai-operations-spec` | Standardize |
+| `agenticops-control-tower` | Operate |
+
+- **AgenticLens** remains package-first observability, evaluation, and
+  operational intelligence
+- **Agentic Sidecar** remains package-first supervision and governance
+- **Agentic Chaos** remains package-first resilience and fault injection
+- **Agentic MCP** remains the MCP-native access layer
+- **AI Operations Specification** remains the shared operational contract
+- **Control Tower** becomes the centralized operate/manage layer across them
+
+This repository should therefore stay focused on:
+
+- inventory and registry concerns
+- control-plane APIs
+- capability discovery contracts
+- health and readiness visibility
+- centralized operations and configuration
+- multi-agent, multi-environment control-room workflows
+
+It should not quietly turn into a duplicate implementation of the sibling
+projects.
+
+## Initial scope
+
+The concept doc describes a very broad end state. A good first implementation
+needs to be much narrower.
+
+The first usable version should likely prove four things only:
+
+1. agents can register and heartbeat
+2. the system can discover installed DeepAgentLabs capabilities and versions
+3. operators can inspect that inventory through a simple API and CLI
+4. the same inventory can be surfaced later in a console without changing the
+   underlying control model
+
+That is enough to validate the control-plane idea without pretending the full
+dashboard, configuration orchestration, and cross-agent operations engine
+already exist.
+
+## Roadmap
+
+The build plan is in [ROADMAP.md](ROADMAP.md). In short, the intended order
+should be:
+
+- start with a narrow registry and discovery core
+- add a real control API and CLI before building the dashboard
+- surface Lens, Sidecar, and Chaos data gradually rather than simulating a
+  complete integration layer
+- add MCP connectivity to Control Tower after the underlying control surfaces
+  are real
+
+If you want the full architectural reasoning behind those choices, read the
+concept doc first and the roadmap second.

agenticops_control_tower-0.0.1.dist-info/RECORD

@@ -0,0 +1,21 @@
+agenticops_control_tower/__init__.py,sha256=61wxMKH4DGduCllcmDdiqlb_kepXCS3eMymczEGGe04,110
+agenticops_control_tower/adapters/__init__.py,sha256=XtsNvzmekjd_6r3ToYas-sP0s-1uFt7TvOeYCeTPnlA,108
+agenticops_control_tower/adapters/catalog.py,sha256=cmvYsVz961Y9FoyriJApo321rKTeFL4VPluOOe-OAk0,168
+agenticops_control_tower/api/__init__.py,sha256=kR51genXB-bD_S6oGCjIW6x6UxTzJeoO2iDirsDWvkc,107
+agenticops_control_tower/api/surface.py,sha256=MmRqDbj1qFvgk8XB5P2JO-2WF0P0qVBvl9K2xKT0oDI,899
+agenticops_control_tower/cli/__init__.py,sha256=4kEEfC9ZwIa9hxFKgQqIycgy9TiUL4oC_NSEwFDQVig,24
+agenticops_control_tower/cli/main.py,sha256=PFu0cLLYdsoe1FjRmlUqkPdx6QDVZyxf53vFPZCbI5I,308
+agenticops_control_tower/config/__init__.py,sha256=J_Y5bKWBvYLNZchWmUVuGKsUMAvtMoupQqKm_gH0-i4,122
+agenticops_control_tower/config/models.py,sha256=n6YTda_b_RULN7bTIuHsbSU_GRBWcP5LG0dMum7G_XI,490
+agenticops_control_tower/console/__init__.py,sha256=fM845KVyxz8p-K8PsICMD1Bj8y_G-RUK-6A68uSJ_w0,32
+agenticops_control_tower/console/app.py,sha256=G-Oy3f_1W8hzVWQzFzJVk-_QHO0EHhKwhjvHkOk-ysw,156
+agenticops_control_tower/discovery/__init__.py,sha256=KLe7TpItYKZ6lzIACdNBwPDwS1ex9_W7HA92b6iURR8,132
+agenticops_control_tower/discovery/service.py,sha256=2_bmnhk_se_PwbmEaq098kf_PhscaXMSmcpDY1CWjqc,555
+agenticops_control_tower/models/__init__.py,sha256=taX-27pcbiU7zUAj262fOP49TkB7-YbpizOY1IOXhRw,175
+agenticops_control_tower/models/agent.py,sha256=gH81kQuw5njjFBvAcRWfnsz2OSyucAidnc18OFG-ACM,1016
+agenticops_control_tower/registry/__init__.py,sha256=E-YX9LmbUxoirPtoDKhJ1IFidrNfmqyI-lKuqHY82HI,98
+agenticops_control_tower/registry/service.py,sha256=WEAy-H5KpNTZY66AogMvS8HeCoNK25gEZ6L0loj3yPo,939
+agenticops_control_tower-0.0.1.dist-info/METADATA,sha256=iZZc8i61vNwV7z0iBPdkKYPeh5Lpc5X96UDTYeM_UrY,12192
+agenticops_control_tower-0.0.1.dist-info/WHEEL,sha256=zOwg4jB6zX2kU910N-cMawjivD6tO8NEWvE12je1bVk,87
+agenticops_control_tower-0.0.1.dist-info/licenses/LICENSE,sha256=lvV6QrIxN4zuHKwVLpiYXXX_tQecwGTAYsiIAw3Cd3A,1095
+agenticops_control_tower-0.0.1.dist-info/RECORD,,

agenticops_control_tower-0.0.1.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.32.0
+Root-Is-Purelib: true
+Tag: py3-none-any

agenticops_control_tower-0.0.1.dist-info/licenses/LICENSE

@@ -0,0 +1,22 @@
+MIT License
+
+Copyright (c) 2026 agenticops-control-tower Contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+