convez.ai
AgenteDevOps & InfraestruturaAvançado
sozercan

Orka

sozercan/orka

Orquestração de agentes IA nativa do Kubernetes com execução isolada e observabilidade completa

Ver no GitHub
InicialPluginScore · de 0 a 100

Plataforma nativa de Kubernetes para orquestração de agentes de IA. Transforma seu cluster em um executor de tarefas alimentado por IA, permitindo que enxames de agentes trabalhem em paralelo com segurança, auditoria completa e escalabilidade automática gerenciada pelo Kubernetes.

Instalação

$npx convez-ai sozercan/orka

1 comando no terminal: detecta o formato do repositório (marketplace ou plugin avulso) e instala via Claude Code. Requer Node 18+ e o Claude Code instalado.

Métricas

Estrelas
49
Forks
29
Acompanhando
0
Saúde
42%
Último commit
há 1 dia
Versão
v0.3.0
Issues abertas
345
Contribuidores
3

Casos de uso

  • Revisão paralela de código com múltiplos agentes especializados
  • Automação de workflows de desenvolvimento com decomposição dinâmica de tarefas
  • Pesquisa com hipóteses concorrentes entre agentes independentes
  • Operações agendadas (varreduras de segurança, auditorias de dependências)
  • Integração com CI/CD e controle centralizado de credenciais LLM

Veredito

Orka é uma solução experiente e promissora para equipes que já operam Kubernetes e buscam orquestração de agentes IA com segurança de classe empresarial. A abstração nativa de Kubernetes é adequada, mas a API ainda está em desenvolvimento — não recomendado para produção crítica hoje.

README

A tradução para o português deste README ainda está na fila.

Orka

Kubernetes-native AI agent orchestration.

Getting Started · Architecture · API Reference · Documentation


Orka turns your Kubernetes cluster into an AI-powered task execution platform. Spin up swarms of AI agents that write code, review PRs, research topics, or run containers — each as an isolated Kubernetes Job with full scheduling, retries, and observability. A coordinator agent dynamically decomposes complex tasks, spawns specialist agents to work in parallel, and synthesizes their results — no manual orchestration graphs required.

One helm install, one LLM secret, and you're chatting with an orchestrator that handles the rest.

[!IMPORTANT] Orka is experimental and under active development. APIs, CRDs, and behavior may change without notice between releases, and it is not yet recommended for production use. Feedback, bug reports, and feature ideas are very welcome — please open an issue.

Why Run AI Agents on Kubernetes?

No API keys on developer machines — LLM credentials live in Kubernetes Secrets, managed by your platform team. Developers connect via ServiceAccount tokens — no risk of leaked keys in dotfiles, shell history, or laptops.

Centralized control — One place to set model policies, rate limits, and allowed providers across every team. Swap models or providers without touching developer configs.

Every agent action is auditable — Tasks run as Kubernetes Jobs with full logs, Prometheus metrics, and result storage. Know exactly what every agent did, when, and at what cost.

Isolated execution — Each agent runs in its own Pod with a hardened security context: non-root, read-only rootfs, all capabilities dropped, seccomp enforced. Agents can't escape their sandbox.

Scale with your cluster — Priority scheduling, retry policies, concurrency limits, and cron-based execution — all handled by the Kubernetes control plane you already operate.

What Can You Build?

Parallel code review — Spawn a swarm of review agents — security, performance, test coverage, accessibility, whatever you need. Each reviews independently and in parallel, then the coordinator synthesizes findings into a single report.

Autonomous dev workflows — A coordinator agent dynamically breaks down a feature request, delegates implementation to specialist agents (backend, frontend, tests), and opens a PR with the combined result — no predefined workflow graphs.

Research with competing hypotheses — Multiple agents investigate different theories in parallel, challenge each other's findings, and converge on the strongest explanation. The adversarial structure avoids the anchoring bias of sequential investigation.

Scheduled operations — Cron-based agents that run daily security scans, dependency audits, or report generation — all with retry policies and webhook notifications.

Use your favorite AI client — Connect Continue, Cursor, or any OpenAI-compatible client to Orka's API. Your cluster manages the LLM credentials — developers just code.

CI/CD integration — Trigger agent tasks from GitHub Actions, monitor progress via the REST API, and gate deployments on agent analysis.

Features

  • 🤖 AI Agents — Anthropic, OpenAI, or Azure OpenAI with tools, skills, and session persistence
  • 🛠️ Agent Runtimes — Delegate repo-backed coding tasks to Codex CLI, Claude Code CLI, or GitHub Copilot CLI
  • 🔁 Autonomous Task Loops — Coordinators can iterate on long-running goals until complete, canceled, or at an iteration limit
  • 🔀 Multi-Agent Coordination — Coordinators delegate to specialists with depth and concurrency controls
  • 💬 Interactive Chat — Agentic orchestrator with SSE streaming that creates and manages agents and tasks for you
  • 🧠 Durable Memory — Namespace-scoped recall, transcript search, and reviewable memory proposals that can be applied
  • 🛡️ Repository Security Scanning — Scheduled and incremental repository scans with threat models, validated findings, patch generation, and remediation PRs
  • 🔎 Repository Monitors — Durable GitHub PR review queues with scheduled and webhook-triggered review runs
  • 🧰 Agent Sandbox Workspaces — Experimental durable, reusable coding workspaces through agent-sandbox
  • 🖥️ Web Dashboard — Built-in React UI embedded in the controller binary — zero extra deployments
  • 📦 Declarative CRDs — Task, Agent, Tool, Provider, Skill, RepositoryScan, and RepositoryMonitor custom resources for GitOps workflows
  • ⏰ Scheduled Tasks — Cron-based recurring execution with concurrency policies
  • 🔌 REST & OpenAI-Compatible API — Full CRUD + /openai/v1/chat/completions endpoint for Continue, Cursor, and any OpenAI-compatible client
  • 🔐 Kubernetes, OIDC & Kontxt TxToken Auth — ServiceAccount tokens by default, with optional OIDC and scoped kontxt transaction-token flows
  • 🔮 Anthropic-Compatible API — /anthropic/v1/messages endpoint for Claude Code and other Anthropic-native clients
  • 📊 Observability — Prometheus metrics, structured logging, health probes
  • 🔒 Hardened by Default — Non-root containers, read-only rootfs, ServiceAccount token auth

Quick Start

Install

helm install orka charts/orka \
  --namespace orka-system \
  --create-namespace

Set Up a Provider

kubectl create secret generic anthropic-secret \
  --from-literal=api-key=your-api-key

kubectl apply -f - <<EOF
apiVersion: core.orka.ai/v1alpha1
kind: Provider
metadata:
  name: anthropic
spec:
  type: anthropic
  secretRef:
    name: anthropic-secret
    key: api-key
  defaultModel: claude-sonnet-4-20250514
EOF

Start Chatting

Use the built-in dashboard, or connect any OpenAI-compatible client:

kubectl port-forward -n orka-system svc/orka-api 8080:8080

# Open the web dashboard
open http://localhost:8080

The built-in orchestrator creates agents, runs tasks, monitors progress, and returns results — all from natural language. See the OpenAI Compatibility and Anthropic Compatibility docs for proxy setup with your preferred client.

Documentation

Getting StartedInstallation, quick start, CLI setup
ArchitectureSystem design, components, and data flow
ConfigurationCRD reference, Helm values, controller flags, metrics
Agent RuntimesCodex CLI, Claude Code CLI, and Copilot CLI runtimes
Agent SandboxExperimental upstream agent-sandbox workspace execution for agent runtimes
Interactive ChatChat endpoint, tools, and SSE streaming
Multi-Agent CoordinationCoordinator agents and task delegation
Autonomous TasksLong-running coordinator loops with persisted plan state
MemoryDurable memory, proposals, transcript search, and validation
API ReferenceREST API endpoints and usage examples
OpenAI CompatibilityOpenAI-compatible chat completions API
Anthropic CompatibilityAnthropic-compatible Messages API
Web DashboardFrontend architecture and pages
SecuritySecurity model and hardening
Kontxt QuickstartUse OIDC identity to call Orka without long-lived tokens
Kontxt TxToken IntegrationTxToken verification, authorization, TTS, and audit guidance
Repository Security ScanningRepository scan workflow, threat models, findings, and remediation
Repository MonitorsDurable GitHub pull request monitor runs, review tasks, and dashboard state
GitHub Label TriggersTrigger Orka agent tasks from GitHub labels such as agent:implement and agent:review
DevelopmentBuilding, testing, and contributing
TestingTest structure, patterns, and commands
Ver o original no GitHub

Bom para

Relacionados