A Kubernetes operator that synthesizes autonomous agents from natural language descriptions.

Language Operator converts natural language goals into executable agents that run in your Kubernetes cluster:

aictl agent create "monitor our API error rates and alert on spikes"

This creates a complete agent with:

• Code synthesized from your description
• Kubernetes deployment (pod, service, network policies)
• Observability integration (OpenTelemetry traces)
• Security isolation (AST validation, network policies)

1. Natural Language → Code

The operator calls an LLM to generate Ruby code from your instructions. You can use cloud models (GPT-4, Claude) or local quantized models (Llama, Mistral).

2. Organic Functions

Agents are composed of tasks with stable input/output contracts. Tasks can be:

• Neural: LLM decides implementation at runtime
• Symbolic: Explicit Ruby code

The caller doesn't know which type it's calling - the contract is the interface.

3. Progressive Optimization

After execution, the system analyzes OpenTelemetry traces to detect patterns. Deterministic neural tasks are automatically converted to symbolic code, reducing cost and latency while preserving the contract.

Initial (fully neural):

task(:check_api,
  instructions: "Check API health",
  outputs: { status: 'string' })

task(:send_alert,
  instructions: "Send alert if unhealthy",
  inputs: { status: 'string' },
  outputs: { sent: 'boolean' })

main do
  result = execute_task(:check_api)
  execute_task(:send_alert, inputs: result)
end

After learning (hybrid):

task(:check_api,
  outputs: { status: 'string' }) do |inputs|
  execute_tool('http', 'get', url: 'https://api.example.com/health')
end

task(:send_alert,  # Kept neural - decision logic varies
  instructions: "Send alert if unhealthy",
  inputs: { status: 'string' },
  outputs: { sent: 'boolean' })

main do  # Unchanged
  result = execute_task(:check_api)
  execute_task(:send_alert, inputs: result)
end

The main block never changes. Implementations evolve without breaking callers.

# Add Helm repository
helm repo add language-operator https://charts.langop.io

# Install operator
helm install language-operator language-operator/language-operator

# Install aictl
gem install language-operator

# Set up your first cluster
aictl quickstart

To ensure code quality, set up the pre-commit hooks:

# Run the setup script to install git hooks
./scripts/setup-hooks

This installs a pre-commit hook that automatically:

• Checks code formatting with go fmt
• Runs static analysis with go vet
• Runs tests for modified packages
• Verifies generated files are up-to-date

To bypass the hook temporarily (not recommended), use:

git commit --no-verify

• Kubernetes 1.26+
• NetworkPolicy-capable CNI (Cilium, Calico, Weave, Antrea)
• Wildcard DNS for agent webhooks (see DNS Setup)
• Optional: GPU nodes for local model inference

Pre-alpha - Core functionality works, but this project is currently experimental.

FSL 1.1 - Converts to Apache 2.0 on 2028-01-01

Use Limitation: Cannot offer Language Operator as a commercial managed service until 2028. Internal use, consulting, and custom deployments are permitted.