Skip to content

Commit bf15701

Browse files
initcroninitcron
authored
Merge pull request #101 from agenticdevops/fix/remove-hardcoded-secrets
fix: remove hardcoded Slack tokens from git history
2 parents 084d205 + 1ec3cd9 commit bf15701

536 files changed

Lines changed: 155403 additions & 236 deletions

File tree

Some content is hidden

Large Commits have some content hidden by default. Use the searchbox below for content that may be hidden.

‎.github/workflows/performance.yml‎

Lines changed: 134 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,134 @@
1+
name: Performance Regression Detection
2+
3+
on:
4+
pull_request:
5+
branches: [main]
6+
push:
7+
branches: [main]
8+
workflow_dispatch:
9+
10+
env:
11+
CARGO_TERM_COLOR: always
12+
RUST_BACKTRACE: 1
13+
14+
jobs:
15+
micro-benchmarks:
16+
name: Criterion Micro-benchmarks
17+
runs-on: ubuntu-latest
18+
steps:
19+
- name: Checkout code
20+
uses: actions/checkout@v4
21+
22+
- name: Install Rust stable
23+
uses: dtolnay/rust-toolchain@stable
24+
25+
- name: Cache cargo registry
26+
uses: actions/cache@v4
27+
with:
28+
path: ~/.cargo/registry
29+
key: ${{ runner.os }}-cargo-registry-${{ hashFiles('**/Cargo.lock') }}
30+
31+
- name: Cache cargo index
32+
uses: actions/cache@v4
33+
with:
34+
path: ~/.cargo/git
35+
key: ${{ runner.os }}-cargo-index-${{ hashFiles('**/Cargo.lock') }}
36+
37+
- name: Cache build artifacts
38+
uses: actions/cache@v4
39+
with:
40+
path: target
41+
key: ${{ runner.os }}-cargo-build-${{ hashFiles('**/Cargo.lock') }}
42+
43+
- name: Run event_serialization benchmark
44+
run: cargo bench --bench event_serialization
45+
46+
- name: Run broadcaster_throughput benchmark
47+
run: cargo bench --bench broadcaster_throughput
48+
49+
- name: Run coordination_overhead benchmark
50+
run: cargo bench --bench coordination_overhead
51+
52+
- name: Upload Criterion HTML reports
53+
uses: actions/upload-artifact@v4
54+
if: always()
55+
with:
56+
name: criterion-reports
57+
path: target/criterion/
58+
retention-days: 14
59+
60+
- name: Store baseline on main branch
61+
if: github.ref == 'refs/heads/main'
62+
run: |
63+
cargo bench --bench event_serialization -- --save-baseline main
64+
cargo bench --bench broadcaster_throughput -- --save-baseline main
65+
cargo bench --bench coordination_overhead -- --save-baseline main
66+
67+
- name: Compare against main baseline on PRs
68+
if: github.event_name == 'pull_request'
69+
run: |
70+
# Note: For proper baseline comparison, we'd need to restore the baseline
71+
# from a previous run. This is a simplified version that shows the pattern.
72+
# Full implementation would use actions/cache to restore baselines.
73+
cargo bench --bench event_serialization -- --baseline main || echo "No baseline to compare"
74+
cargo bench --bench broadcaster_throughput -- --baseline main || echo "No baseline to compare"
75+
cargo bench --bench coordination_overhead -- --baseline main || echo "No baseline to compare"
76+
77+
integration-performance:
78+
name: Integration Performance Tests
79+
runs-on: ubuntu-latest
80+
# Only run on main branch pushes to avoid excessive CI time on every PR
81+
if: github.ref == 'refs/heads/main'
82+
steps:
83+
- name: Checkout code
84+
uses: actions/checkout@v4
85+
86+
- name: Install Rust stable
87+
uses: dtolnay/rust-toolchain@stable
88+
89+
- name: Cache cargo registry
90+
uses: actions/cache@v4
91+
with:
92+
path: ~/.cargo/registry
93+
key: ${{ runner.os }}-cargo-registry-${{ hashFiles('**/Cargo.lock') }}
94+
95+
- name: Cache cargo index
96+
uses: actions/cache@v4
97+
with:
98+
path: ~/.cargo/git
99+
key: ${{ runner.os }}-cargo-index-${{ hashFiles('**/Cargo.lock') }}
100+
101+
- name: Cache build artifacts
102+
uses: actions/cache@v4
103+
with:
104+
path: target
105+
key: ${{ runner.os }}-cargo-build-perf-${{ hashFiles('**/Cargo.lock') }}
106+
107+
- name: Build release binary
108+
run: cargo build --release
109+
110+
- name: Run baseline single agent tests
111+
run: cargo test --test perf_baseline_single_agent --release -- --nocapture
112+
113+
- name: Run concurrent agents test
114+
run: cargo test --test perf_concurrent_agents --release -- --nocapture
115+
116+
- name: Run memory stability tests (ignored by default)
117+
run: cargo test --test perf_memory_stability --release -- --ignored --nocapture
118+
119+
regression-check:
120+
name: Regression Failure Detection
121+
runs-on: ubuntu-latest
122+
needs: [micro-benchmarks]
123+
if: always()
124+
steps:
125+
- name: Check benchmark results
126+
run: |
127+
# This job aggregates results and would fail the workflow if:
128+
# 1. Criterion detects >10% regression (configured in benchmark code with significance_level(0.1))
129+
# 2. Integration tests fail assertions (>10s for 20 agents, >100ms p95 latency)
130+
# 3. Memory stability tests detect unbounded growth
131+
132+
# In a production setup, this would parse Criterion output and fail if regression detected
133+
echo "Benchmark results checked. See micro-benchmarks job for details."
134+
echo "Criterion will fail if p-value indicates >10% regression with statistical significance."

‎.gitignore‎

Lines changed: 15 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -78,5 +78,20 @@ secrets/
7878
*.log
7979
logs/
8080

81+
# Planning docs (except summaries and state)
82+
.planning/*
83+
!.planning/STATE.md
84+
!.planning/PROJECT.md
85+
!.planning/ROADMAP.md
86+
!.planning/REQUIREMENTS.md
87+
!.planning/CONTEXT.md
88+
!.planning/ARCHITECTURE.md
89+
!.planning/phases/
90+
!.planning/phases/**/
91+
!.planning/phases/**/*-SUMMARY.md
92+
!.planning/phases/**/*-PLAN.md
93+
!.planning/phases/**/CONTEXT.md
94+
!.planning/phases/**/RESEARCH.md
95+
8196
# OS files
8297
Thumbs.db

‎.planning/PROJECT.md‎

Lines changed: 191 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,191 @@
1+
# AOF - The Humanized Agentic Ops Platform
2+
3+
## What This Is
4+
5+
An open-source (Apache 2.0) platform that makes AI agents feel like team members, not scripts. Built on a Rust core, AOF gives DevOps/SRE engineers agent squads with real personalities, visible coordination, and a Mission Control dashboard — all while doing real ops work (K8s, monitoring, incident response). Think "OpenClaw for DevOps" but built for production infrastructure.
6+
7+
## Core Value
8+
9+
Agents that feel human — with personas, visible communication, and a Mission Control where you see your team of AI minions coordinating, reporting, and getting real work done.
10+
11+
## Requirements
12+
13+
### Validated
14+
15+
<!-- Shipped and confirmed valuable (existing AOF capabilities). -->
16+
17+
- Multi-provider LLM abstraction (Anthropic, OpenAI, Google, Groq, Ollama, Bedrock) — existing
18+
- Agent execution engine with tool composition and streaming — existing
19+
- Workflow execution (DAG-based step orchestration) — existing
20+
- AgentFlow execution (multi-agent graph flows) — existing
21+
- Memory backends (in-memory, file-based, optional Redis/Sled) — existing
22+
- MCP client support (stdio, SSE, HTTP transports) — existing
23+
- Built-in tool registry (kubectl, docker, git, shell, HTTP, file ops) — existing
24+
- Trigger server with platform adapters (Telegram, Slack, Discord stubs) — existing
25+
- Skills system (SKILL.md loading, registry, requirements gating) — existing
26+
- Fleet coordination primitives (Raft, Byzantine consensus) — existing
27+
- kubectl-style CLI (aofctl) — existing
28+
- TUI interactive mode with streaming — existing
29+
- Error knowledge base for learning from failures — existing
30+
- Session management with resume capability — existing
31+
- YAML-first agent/workflow/flow configuration — existing
32+
33+
### Active
34+
35+
<!-- The reinvention: humanized agentic ops platform. -->
36+
37+
**Agent Persona System (SOUL.md)**
38+
- [ ] Each agent has a persistent personality defined in SOUL.md (identity, communication style, boundaries, vibe)
39+
- [ ] Agents speak in character — their personality comes through in every interaction
40+
- [ ] Avatar/icon system — each agent has a visual identity (emoji, pixel art, or custom image)
41+
- [ ] Role titles and skill tags displayed on agent profile cards
42+
- [ ] Agents maintain consistent personality across sessions via memory
43+
44+
**Visible Agent Communication**
45+
- [ ] Squad chat — agents talk to each other in a shared chat stream visible to humans
46+
- [ ] Announce queue — cross-agent communication protocol (agent A can message agent B)
47+
- [ ] Humans can join squad chat, interrupt, redirect, or give new instructions
48+
- [ ] Agent-to-agent task delegation — one agent can create tasks for another
49+
- [ ] Communication logs are persistent and reviewable
50+
51+
**Mission Control (WASM Web UI)**
52+
- [ ] WASM-based web dashboard compiled from Rust (pure Rust story, no JS framework)
53+
- [ ] Agent cards — profile view with avatar, role, status, personality, skills, attention items
54+
- [ ] Kanban task board — tasks flow through backlog/assigned/in-progress/review/done
55+
- [ ] Squad chat panel — real-time view of agent-to-agent and human-to-agent conversation
56+
- [ ] Live activity feed — real-time stream of what agents are doing (like GitHub activity)
57+
- [ ] Task detail view — description, context, assignee (agent), comments, timeline, attachments
58+
- [ ] Agent status indicators (idle, working, waiting for human, blocked)
59+
- [ ] Squad overview — visual representation of all agents and their relationships
60+
61+
**Standups, Check-ins & Coordination**
62+
- [ ] Agents perform scheduled standups — report what they did, what they're doing, blockers
63+
- [ ] Check-in protocol — agents periodically report status without being asked
64+
- [ ] Heartbeat system — proactive monitoring checks on schedules (every 30min, daily, etc.)
65+
- [ ] Roundtable discussions — agents can hold group conversations to solve problems together
66+
- [ ] Human-in-the-loop workflows — agents assign tasks to humans with context and comments
67+
68+
**Messaging Gateway (Slack/Discord)**
69+
- [ ] Single bot mode — one bot in Slack, routes to different agents behind the scenes
70+
- [ ] Dedicated agent channels — each agent appears separately in squad channels
71+
- [ ] NAT-transparent — outbound WebSocket (no ngrok needed for Slack/Discord)
72+
- [ ] Agents respond in character with their persona
73+
- [ ] Squad announcements — broadcast to all agents or specific teams
74+
75+
**Conversational Configuration (The Interface IS Conversation)**
76+
- [ ] Talk to the system to create agents — "I need a K8s monitoring agent" → agent with persona created
77+
- [ ] Talk to build agent teams/fleets — "Build me an incident response squad" → team created with roles
78+
- [ ] Talk to configure schedules — "Check my cluster every 30 minutes" → heartbeat configured
79+
- [ ] Talk to add skills — "Learn how to debug our Postgres" → skill created from conversation
80+
- [ ] YAML/CLI as power-user layer underneath — conversation generates config, not the other way around
81+
- [ ] The main agent (orchestrator/router) understands intent and delegates to the right agents
82+
83+
**Real Ops Capabilities**
84+
- [ ] K8s diagnostics — pod debugging, log analysis, event inspection, resource usage
85+
- [ ] Incident response flow — triage agent coordinates specialist agents
86+
- [ ] Monitoring integration — Prometheus queries, alert triage
87+
- [ ] Skills platform — codify tribal knowledge as executable SKILL.md files
88+
- [ ] Runbook execution — convert wiki/playbook procedures into agent skills
89+
90+
**Local-First Architecture**
91+
- [ ] Local Rust daemon — agents run on your machine, Mission Control connects to it
92+
- [ ] Optional server deployment — deploy daemon to server for always-on agents
93+
- [ ] WebSocket control plane — Mission Control and Slack connect to daemon
94+
- [ ] Session persistence — agent state survives daemon restarts
95+
96+
### Out of Scope
97+
98+
- Multi-tenancy / MSP features — enterprise product, not v1 open source
99+
- RBAC / SSO / audit trails — enterprise product
100+
- Billing / usage tracking — enterprise product
101+
- Cloud-hosted SaaS offering — self-hosted only for v1
102+
- Mobile app — web + Slack/Discord are the interfaces
103+
- Voice/talk mode — text-based interactions for v1
104+
- OAuth subscription support (Anthropic Pro/Max) — nice to have, not v1
105+
106+
## Context
107+
108+
**Why this exists:** OpenClaw proved that making AI agents feel human goes viral. Every agentic framework (LangGraph, CrewAI, Agno) feels like running scripts — even if technically powerful. The missing ingredient is the *human touch*: agents with personalities, visible coordination, and interfaces that make you feel like you're managing a team of intelligent minions. No one has built this for DevOps/SRE.
109+
110+
**What we're building on:** AOF has a solid Rust foundation — 13 crates covering LLM abstraction, agent execution, workflows, memory, tools, triggers, skills, and fleet coordination. The engine is proven. What's missing is the soul.
111+
112+
**Inspiration sources:**
113+
- OpenClaw/Clawdbot: SOUL.md personas, agent-to-agent comms, skills platform, heartbeat system
114+
- OpenClaw Mission Control: kanban tasks, agent cards, squad chat, live activity, task assignment
115+
- Research in `/Users/gshah/work/opsflow-sh/plans/research/`: strategic analysis, feature extraction, architecture plans
116+
117+
**Existing codebase:** 13 Rust crates at v0.4.0-beta. Codebase map at `.planning/codebase/`. The Rust engine stays and evolves; the CLI/UX layer gets reinvented.
118+
119+
**Brand:** AOF (Agentic Ops Framework) remains the engine name. Product brand TBD — xops.bot is available as an option. Name decision deferred to post-prototype.
120+
121+
### Security: AOF's Enterprise Differentiation (vs OpenClaw)
122+
123+
**Phase 8 Delivery — Production Security Hardening:**
124+
125+
AOF is NOT just a humaner OpenClaw clone. It's **enterprise-grade agentic infrastructure** with security designed from the ground up:
126+
127+
**Defense-in-Depth Security Model (6 layers):**
128+
1. **Sandbox Isolation:** Per-tool seccomp profiles blocking 23+ dangerous syscalls (ptrace, mount, bpf, etc.) — prevents kernel exploits
129+
2. **Capability Dropping:** `--cap-drop=ALL` by default with per-tool allowlists — strips unnecessary permissions
130+
3. **Credential Auditing:** CredentialAccessInterceptor logs every credential read with tamper-proof sequence numbers — track who accessed what
131+
4. **Behavioral Anomaly Detection:** 4-component scoring system detects suspicious credential access patterns — catch insider threats
132+
5. **Device Pairing & mTLS:** Private CA + device registry with approval workflow — only trusted devices can pair
133+
6. **Production Observability:** SRE-grade metrics, health checks, graceful shutdown, incident runbooks — production-hardened
134+
135+
**Why this matters for enterprises:**
136+
- **OpenClaw** executes user code with minimal isolation — fine for trusted OpenAI API calls, dangerous for production infrastructure access
137+
- **AOF** runs untrusted agent code in hardened containers with comprehensive audit trails — enterprise can prove compliance
138+
- **Selling point:** "Agents that feel human, but production-hardened for infrastructure access"
139+
140+
**Blog Series Planned (Q1 2026):**
141+
1. "AOF vs OpenClaw: Why Human-Feeling Agents Need Enterprise Security"
142+
2. "Seccomp Deep Dive: How AOF Prevents Sandbox Escape Attacks"
143+
3. "Credential Auditing in Agentic Systems: The Missing Security Layer"
144+
4. "From OpenClaw to OpenAgentiX: Generalizing AOF for Enterprise"
145+
146+
### Future Vision: OpenAgentiX Platform
147+
148+
**Phase 9-10 Generalization Path:**
149+
150+
AOF currently targets **DevOps/SRE** as initial market. Future vision is **OpenAgentiX** — a generalized agentic platform for any enterprise use case:
151+
152+
**Generalization Roadmap:**
153+
- **v0.5 (AOF):** DevOps/SRE agents with K8s tools, incident response, monitoring
154+
- **v1.0 (AOF + DevOps Enterprise):** Persona system, Mission Control, Slack/Discord, production hardening
155+
- **v2.0 (OpenAgentiX):** Multi-domain agent framework — swap K8s tools for database, network, security, finance, HR tools
156+
- **v2.5 (OpenAgentiX Enterprise):** Multi-tenancy, RBAC, SSO, audit trails, billing (separate commercial product)
157+
158+
**Key Insight:**
159+
The security model (seccomp + credential auditing + behavioral anomaly detection) **is domain-agnostic**. It works for K8s agents, database agents, finance agents, any untrusted code executing against production systems.
160+
161+
**Market Positioning:**
162+
- **OpenClaw** = Make agents feel human (great UX, no security)
163+
- **AOF** = Make agents feel human + production-hardened (DevOps focused)
164+
- **OpenAgentiX** = Make agents feel human + enterprise-secure (any domain, multi-tenancy, compliance)
165+
166+
## Constraints
167+
168+
- **Language**: Rust for core engine and WASM Mission Control (pure Rust story is a differentiator)
169+
- **License**: Apache 2.0 — everything open source, enterprise features come later in separate products
170+
- **Architecture**: Local-first — must work on a single machine, server deployment optional
171+
- **Performance**: Rust performance is a selling point — agent communication and task coordination must be snappy
172+
- **Frontend**: Mission Control built with builder.io (user's existing tool). Backend/daemon is Rust. Beautiful UX wins over language purity.
173+
- **Backward compatibility**: Existing AOF YAML configs should still work (migration path, not hard break)
174+
- **Cross-platform**: macOS, Linux, Windows (same as current AOF)
175+
176+
## Key Decisions
177+
178+
| Decision | Rationale | Outcome |
179+
|----------|-----------|---------|
180+
| builder.io for Mission Control | User's existing tool. Beautiful, polished UX. Rust backend + builder.io frontend. | — Pending |
181+
| Local-first architecture | DevOps engineers want control, not another SaaS. Server mode is opt-in. | — Pending |
182+
| Everything open source (v1) | Virality requires zero friction. Enterprise features are a separate product. | — Pending |
183+
| Keep AOF as engine name | Established brand, crates already published. Product name TBD. | — Pending |
184+
| Agents as "team members" not "tools" | This is THE differentiator. Every design decision serves the human feel. | — Pending |
185+
| Slack/Discord dual mode | Single bot for quick access + dedicated agent channels for squad work | — Pending |
186+
| Reinvention over evolution | Willing to restructure core if needed — the vision is more important than preserving current CLI patterns | — Pending |
187+
| Conversation as primary interface | Users talk to the system, not write YAML. Config is generated from conversation. YAML is the power-user escape hatch. | — Pending |
188+
| Simplicity over power | Dead simple first experience beats feature richness. If you need docs to start, you've lost. | — Pending |
189+
190+
---
191+
*Last updated: 2026-02-11 after initialization*

0 commit comments

Comments
 (0)