Open Source

AI Change Controller for Git

GitOps for Code, Not YAML

Kubernetes-native CRDs for orchestrating AI code agents. Define tasks declaratively, let controllers handle execution, and integrate with your existing GitOps workflows.

terminal
$ kubectl apply -f agent-job.yaml
agentjob.nominos.io/update-dependencies created

$ kubectl get agentjobs
NAME                  STATUS    PROGRESS   AGE
update-dependencies   Running   3/7        45s

$ kubectl logs -f job/update-dependencies
[agent] Analyzing package.json...
[agent] Found 12 outdated dependencies
[agent] Updating lodash@4.17.21 → 4.18.0
[agent] Running tests... ✓ passed
[agent] Creating pull request...

Kubernetes-Native AI Orchestration

Manage AI agents the same way you manage everything else in Kubernetes.

Declarative Tasks

Define AI agent tasks as Kubernetes resources. Apply with kubectl, manage with GitOps, version in git.

Reconciliation Loops

Kubernetes-style controllers continuously reconcile desired state. Failed tasks retry, conflicts resolve, state synchronizes.

Native Integration

Works with your existing Kubernetes tooling—Helm, Kustomize, ArgoCD, Flux. No new paradigms to learn.

Full Audit Trail

Every action logged as Kubernetes events. Integrate with your existing observability stack for complete visibility.

Custom Resource Definitions

Four CRDs to orchestrate any AI code automation workflow.

AgentJob

Kind: AgentJob

Single AI task with full lifecycle management. Define the task, point at a repo, let the controller handle execution.

YAML
apiVersion: nominos.io/v1
kind: AgentJob
metadata:
  name: update-dependencies
  namespace: automation
spec:
  task:
    description: "Update all npm dependencies to latest"
  repository:
    url: https://github.com/myorg/myapp
    branch: main
    createPR: true
  agent:
    model: claude-sonnet-4
    maxTurns: 25
  verification:
    requireCI: true
    requireReview: false

AgentPlan

Kind: AgentPlan

Orchestrate multi-step tasks with dependency ordering, AI decomposition, and configurable execution modes.

YAML
apiVersion: nominos.io/v1
kind: AgentPlan
metadata:
  name: security-patch-fleet
spec:
  decompositionMode: manual
  executionMode: mixed
  failureStrategy: ContinueOnFailure
  repository:
    url: https://github.com/myorg/myapp
    baseBranch: main
    createPR: true
  steps:
    - name: patch-auth-service
      task: "Apply CVE-2024-1234 fix"
    - name: patch-api-gateway
      task: "Update vulnerable dependency"
      dependsOn: [patch-auth-service]
    - name: update-shared-lib
      task: "Bump shared library version"
      dependsOn: [patch-auth-service, patch-api-gateway]

MergeQueue

Kind: MergeQueue

Intelligent merge queue with conflict resolution, automatic rebasing, and rollback on CI failure.

YAML
apiVersion: nominos.io/v1
kind: MergeQueue
metadata:
  name: main-queue
spec:
  targetBranch: main
  mergeStrategy: squash
  conflictResolution:
    enabled: true
    strategy: rebase
  verification:
    requiredChecks:
      - ci/build
      - ci/test
      - security/scan
  autoRevert:
    enabled: true
    triggerOn: [ci-failure, test-failure]

AgentPolicy

Kind: AgentPolicy

Define governance rules for what agents can and cannot do. Enforce standards across your organization.

YAML
apiVersion: nominos.io/v1
kind: AgentPolicy
metadata:
  name: production-safety
spec:
  selector:
    namespaces: [production, staging]
  rules:
    - name: require-review
      action: RequireApproval
      conditions:
        - pathPattern: "src/core/**"
        - pathPattern: "*.sql"
    - name: block-secrets
      action: Deny
      conditions:
        - contentPattern: "(api_key|password|secret)"
    - name: limit-scope
      action: Warn
      conditions:
        - filesChanged: "> 50"

Built for Real Workflows

From dependency updates to security patches, nominos-core handles it declaratively.

Dependency Updates

Automate dependency updates across your fleet. AI agents understand breaking changes and generate migration code.

  • Batch updates across monorepos
  • Intelligent breaking change detection
  • Parallel PR creation
  • Automatic conflict resolution
$ kubectl apply -f dependency-update-plan.yaml

Large-Scale Refactors

Execute organization-wide refactoring campaigns. Rename APIs, update patterns, migrate frameworks declaratively.

  • Consistent changes across repos
  • GitOps-native rollout
  • Track progress via kubectl
  • Automatic rollback on failure
$ kubectl apply -f api-migration-plan.yaml

Security Response

Respond to CVEs at scale. Deploy patches across your fleet with verification gates and compliance audit trails.

  • Rapid fleet-wide patching
  • Priority-based rollout
  • Verification gates
  • Complete audit trail
$ kubectl apply -f cve-response-plan.yaml

Get Started in Minutes

Install via Helm, Kustomize, or raw manifests. Your choice.

# Add the nominos-core Helm repository
helm repo add nominos https://charts.nominos.io
helm repo update

# Install the CRDs and controllers
helm install nominos-core nominos/nominos-core \
  --namespace nominos-system \
  --create-namespace \
  --set anthropic.apiKeySecret=anthropic-credentials
# kustomization.yaml
apiVersion: kustomize.config.k8s.io/v1beta1
kind: Kustomization

resources:
  - https://github.com/nominos-io/nominos-core//config/default?ref=v0.1.0

# Apply with: kubectl apply -k .
# Install CRDs
kubectl apply -f https://github.com/nominos-io/nominos-core/releases/latest/download/crds.yaml

# Install controllers
kubectl apply -f https://github.com/nominos-io/nominos-core/releases/latest/download/controller.yaml

# Create API key secret
kubectl create secret generic anthropic-credentials \
  --namespace nominos-system \
  --from-literal=api-key=sk-ant-xxxxx

Who Uses nominos-core

Platform Engineering

Build internal developer platforms with AI-powered automation that scales with your organization.

  • Declarative automation via CRDs
  • GitOps-native workflows
  • Self-service for dev teams

SRE Teams

Maintain reliability at scale with automated, verified changes using familiar Kubernetes patterns.

  • Reconciliation loops
  • Automatic rollback
  • Integrated observability

Security Teams

Enforce policies and respond to vulnerabilities with governance built into the platform.

  • AgentPolicy for guardrails
  • Audit trail via K8s events
  • Compliance reporting

DevOps Teams

Integrate AI agents into existing CI/CD pipelines and GitOps workflows without learning new tools.

  • Works with ArgoCD/Flux
  • Helm chart available
  • kubectl-native management

Ready to automate your codebase?

nominos-core is MIT licensed and free forever. Star us on GitHub, join the community, or try the hosted dashboard.

MIT License — Free forever