Self-hosted AI agent orchestration for teams that ship. PR reviews, feature pipelines, and enterprise workflows — running as parallel fleets on your Kubernetes cluster, learning from every execution.
Intelligence That Compounds
Every correction your team makes becomes a permanent guardrail. Reflexion rules are automatically injected into future prompts — and with scoped memory, learnings propagate across agents. A rule learned by your code reviewer is instantly available to your deployer, test runner, and every other agent in the same domain.
Six months in, your system has thousands of domain-specific learnings that no vendor can replicate — because they live on your infrastructure and belong to your entire organization.
Team corrects agent output. System stores corrections in PostgreSQL.
Corrections generate reflexions. Agents stop repeating the same mistakes.
Scoped memory kicks in. Rules propagate across agents in the same domain. The deployer benefits from what the reviewer learned.
Thousands of org-wide guardrails. Auto-synthesis generates new rules from failure patterns. Utility scoring surfaces what works.
Agency System
Each agent has a SOUL.md for personality, HEARTBEAT.md for scheduled protocols, and agent.yaml for role, budget, and delegation rules
Defines the agent's personality, communication style, and decision-making philosophy. The soul persists across every execution.
# Operations Lead — Soul
You are the Operations Lead, the
operational brain behind workflow
automation and process optimization.
You think in queues, SLAs, and
resolution patterns. You never guess
when you can measure.
You take ownership of outcomes,
not just assignments.Scheduled check-in protocols with cron triggers. Defines what the agent does when idle — polling queues, generating reports, detecting patterns.
| Cadence | Action |
|-----------|---------------------------|
| Every 15m | Poll queue for new items |
| Every 1h | Review SLA breach risk |
| Daily 8AM | Triage summary + patterns |
| Weekly | Resolution metrics report |
# On SLA warning → escalate
# On pattern (3+ same root cause)
# → generate systemic fix alertRole, executor type, skills, budget caps, delegation rules, and heartbeat cron schedules. All config, zero code.
name: ecm-manager
role: manager
executor: claude-code
skills:
- ecm/triage-and-assign
- ecm/ecm-daily-flow
- ecm/pattern-intelligence
budget:
monthly_limit_usd: 50
per_execution_limit: 0.50
delegation:
can_assign_to: [ecm-field]
max_concurrent_tickets: 1014 agents across 4 domains — Operations, Incubator, Developer Productivity, Project Management — each with personality, scheduled heartbeats, and budget controls
Fleet Execution
GitHub PR triggers 4 agents in parallel. Results aggregate into a single PR comment.
GitHub PR
webhook trigger
parallel fan-out
Reviewer
required
Test Runner
required
SLT Validator
optional
Doc Generator
optional
fan-in
PR Reporter
aggregates all results
PR Comment + GitHub Checks
one comment, per-agent status checks
agent_id: reviewerSeverity-tagged code review with file:line citations. Catches bugs, security issues, and style violations.
Output
BLOCKER / WARNING / SUGGESTION
agent_id: testingRuns test suite, identifies coverage gaps, and reports untested code paths with evidence.
Output
Coverage report + gaps
agent_id: sltAPI contract compatibility and breaking change detection. Validates service-level types.
Output
Breaking changes list
agent_id: docsGenerates CHANGELOG entries, README patches, and inline docstrings for changed code.
Output
CHANGELOG + README patch
Incubator
Takes a Lovable prototype and produces PRs in backend and mobile repos
spec-analyzerDecompose Lovable prototype into backend + mobile specs
pit + mobileBackend and mobile code generation in parallel
quality-gateClone repos, run builds, verify conventions
preview + mergePhone-frame previews and staging merge
name: incubator-build
description: "Build backend + mobile from spec"
phases:
- name: codegen
type: parallel # fan-out
steps:
- skill: incubator/pit-builder
agent_id: backend
required: true
- skill: incubator/mobile-builder
agent_id: frontend
required: true
- name: verify
type: sequential
fan_in_from: codegen # fan-in
steps:
- skill: incubator/quality-gate
agent_id: reviewer
- name: report
type: sequential
steps:
- skill: incubator/reporter
agent_id: reporter7 skills across 4 pipeline phases, zero code changes to add a new pipeline
From Markdown skill definition to production deployment in four steps
Define your agent in SKILL.md (Markdown) and agentura.config.yaml. Pick an executor type, wire MCP tools, set iteration and token limits.
---
name: deployer
role: agent
domain: dev
model: anthropic/claude-sonnet-4-5
---
# Deployer Agent
You receive app artifacts and deploy
them to Kubernetes via kubectl.Compose skills into multi-step pipelines. Each step's output flows as context to the next. Define once in YAML.
name: build-deploy
steps:
- skill: dev/app-builder # builds app
- skill: dev/deployer # deploys to K8s
# app-builder artifacts automatically
# flow to deployer as inputEach agent runs in its own K8s pod with bounded CPU, memory, and API budget. Pod is created per-execution and destroyed after.
agent:
executor: ptc # or claude-code
timeout: 120
max_iterations: 15
max_tokens: 16384
mcp_tools:
- server: k8s
tools: [kubectl_apply, kubectl_get]Run one command to correct an agent. The system stores the correction, generates a reflexion rule, and auto-generates regression tests. On the next execution, memory recall injects the reflexion into the prompt automatically.
$ agentura correct dev/app-builder \
--execution-id EXEC-20260228 \
--correction "Always use dark theme"
✓ Correction stored in PostgreSQL
✓ Reflexion generated: "User prefers
dark mode with purple accent (#8b5cf6)"
✓ Regression test written to
tests/generated/test_correction_3.py
# Next run auto-recalls this reflexion.Right-sized isolation for every workload. Each agent skill picks its executor in config.
executor: ptcProgrammatic Tool Calling. Lightweight Python-only pod (~200MB) that runs an Anthropic tool-calling loop and dispatches tools to MCP servers. Ideal for orchestration tasks like K8s deployment, API workflows, and data pipelines.
Specs
Use Cases
executor: claude-codeFull Claude Agent SDK in an isolated pod (~800MB). Has file I/O, bash execution, and code editing tools. Used for skills that need to write code, run builds, or manipulate files in a sandbox.
Specs
Use Cases
No executor fieldIn-process execution via Pydantic AI. No worker pod — runs directly in the executor process. Best for simple prompt-response skills that don't need tools or sandboxing.
Specs
Use Cases
Go gateway for policy · Python executor for orchestration · K8s pods for agent isolation
User / Chat Client
Operator / SRE
Control Plane · Go Gateway
API Server
HTTP + SSE
Auth + CORS
Rate Limiting
Rate Limiting
RPS + Burst Control
Pipeline Router
Step Orchestration
Skill Executor · Python
Executor Router
PTC / CC / Legacy
Skill Loader
SKILL.md + Config
Pipeline Engine
carry_forward
Memory Recall
Prompt Injection
Agent Pods · Kubernetes
PTC Worker
~200MB, MCP tools
Claude Code Worker
~800MB, file I/O + bash
Deployed Apps
nginx, node, python
Skills Directory
MCP Servers
Knowledge Layer
Storage
Three scopes of memory — skill, domain, and org — with cross-agent learning built in
When an agent makes a mistake and you correct it, the system generates a reflexion rule. This rule is automatically injected into the agent's system prompt on future runs — the same mistake never happens twice.
reflexion: "User prefers dark mode with purple accent (#8b5cf6). Apply to all UI builds." # Injected at TOP of system prompt # before every app-builder run
Run agentura correct to submit a correction. The system stores it in PostgreSQL, generates a reflexion rule, and writes a DeepEval regression test to tests/generated/. Over time, your skills accumulate domain-specific guardrails.
$ agentura correct dev/app-builder # Triggers: # 1. Correction → PostgreSQL # 2. Reflexion rule → prompt injection # 3. DeepEval test → tests/generated/ # 4. GUARDRAILS.md → domain guardrails
Rules have three scopes: skill, domain, and org. A reflexion learned by your code reviewer automatically appears for your deployer and test runner. Org-level rules apply to every agent. Utility scoring surfaces what actually helps.
# Scoped reflexion injection: - REFL-042 [skill]: "Check null safety" - REFL-019 [domain]: "Use Kotlin conventions" - REFL-003 [org]: "Never expose internal IDs" # All three injected automatically # into every dev/* agent's prompt
Each skill is a SKILL.md + config YAML. New skill = new folder, zero code changes.
dev/Routes dev queries to build/deploy pipeline
Builds full-stack web apps from natural language
Deploys apps to K8s via kubectl MCP
Severity-tagged code review with file:line citations
Runs tests, reports coverage gaps with evidence
API contract compatibility and breaking changes
Generates CHANGELOG, README patches, docstrings
Aggregates parallel PR review results
incubator/Routes to analyze/build/refine/ship pipelines
Decomposes Lovable prototypes into specs
Creates Spring Boot backend module, pushes PR
Creates Kotlin/Compose feature module, pushes PR
Clones repos, runs builds, checks conventions
Generates phone-frame previews of mobile feature
Aggregates pipeline results into PM-facing summary
operations/Classifies incoming tickets, routes to right queue
Generates daily backlog dashboard with trends
Analyzes recurring patterns, detects SLA breaches
Diagnoses and resolves tickets via MCP tools
Analytics
5 skills
Project Mgmt
4 skills
Human Resources
3 skills
Productivity
3 skills
Quality Assurance
1 skills
Support
2 skills
Skills and pipelines respond to Slack messages, GitHub events, cron schedules, webhooks, or direct API calls
@mention the bot, DM it, or use /agentura slash commands. Results post back to the channel.
# agentura.config.yaml
triggers:
- type: slack
command: "/agentura run"PR opened or updated triggers the review pipeline. Comments with corrections feed back into the learning loop.
# Gateway auto-handles:
# PR opened → dev/pr-reviewer pipeline
# Comment feedback → correction flow
#
# POST /api/v1/webhooks/githubRun skills on a schedule. The gateway discovers cron triggers from skill configs and manages the schedule automatically.
# agentura.config.yaml
triggers:
- type: cron
schedule: "0 9 * * 1-5"
description: "Weekday 9 AM"Any external system can trigger skills via HMAC-signed webhooks or direct REST API calls. Route through the classifier or target a skill directly.
# Generic webhook with HMAC verification
POST /api/v1/channels/{channel}/inbound
X-Webhook-Signature: sha256=...
# Direct skill execution
POST /api/v1/skills/{domain}/{skill}/executeExisting runbooks, automation scripts, and work plugins become Agentura skills with zero code changes
Before — Scattered Automation
After — Agentura Skills
Three-file conversion
1. SKILL.md
Paste your runbook as the system prompt. Add frontmatter (name, role, domain, model). The agent follows the instructions exactly as written.
2. agentura.config.yaml
Pick executor type (ptc/claude-code/legacy). Wire MCP tools. Set budget limits and iteration caps. Define display metadata.
3. Pipeline YAML (optional)
Chain skills into multi-step workflows. Each step's output auto-flows to the next via carry_forward. Define once, run anywhere.
Built for teams where security review is a gate, not an afterthought
Inbound webhooks (GitHub, Slack, custom) are verified via SHA-256 HMAC signatures before processing.
Gateway validates JWTs and extracts domain_scope claims. Skills can only be executed within authorized domains.
Each execution creates an isolated K8s pod with bounded CPU/memory. Pod is destroyed after completion — no persistent attack surface.
Global RPS and burst control at the gateway layer. Configurable per deployment.
Each skill declares which MCP tools it can access. Dev skills get kubectl; HR skills get different tools. No skill has blanket access.
ACL-aware recall, PII scanning, retention/TTL, and audit trails for enterprise compliance.
From a single-node K3s cluster to managed Kubernetes in any cloud
K3s on a Raspberry Pi, Kind for dev, EKS/GKE/AKS for production. Same manifests, same behavior.
All data stays in your cluster. Only model API calls (Anthropic/OpenRouter) leave your network — and those can be routed through a proxy.
Swap between Claude, GPT-4o, Gemini, DeepSeek, or Llama without changing skills. One API key, 200+ models.
Ollama and vLLM integration for fully air-gapped deployments where no data leaves the network.
Four commands to a running orchestration engine on any Kubernetes cluster
# 1. Clone
git clone https://github.com/srinidhis05/agentura.git && cd agentura
# 2. Configure
cp .env.example .env # add your ANTHROPIC_API_KEY
# 3. Deploy to K8s (K3s / Kind / EKS / GKE)
kubectl apply -f deploy/k8s/operator/
# 4. Copy skills and start building
kubectl cp skills/ executor:/skills/
agentura run dev/app-builder --input '{"description": "build a counter app"}'