“Whose files are these?”
Every agent run shares one box. One run's half-finished branch and stray files leak into the next.
On Kubernetes, every isolated ConvOps run is its own Job: a fresh pod with its own volume and secret, locked down, time limited, and gone when the work is done.
one job per run · per-run secret · no service-account token · pod security restricted
One Kubernetes Job per run: a fresh pod with its own volume and Secret, no service-account token, Pod Security restricted, isolated by NetworkPolicy and deleted when the run ends.
ConvOps is the operations layer for AI agents. It holds your team's process as workflows with gates, a shared memory, scheduled and unattended runs, programs, a plan board, metrics and a full audit trail. It does not sell or host models.
key facts · october 2026
best for
not for
updated
Agents on a shared server or a laptop share its disk, its keys and its fate. Nobody owns the blast radius.
“Whose files are these?”
Every agent run shares one box. One run's half-finished branch and stray files leak into the next.
“Who has the keys?”
Tokens live on laptops and shared servers, readable by every job that runs there.
“Can anyone stop it?”
A runaway agent keeps going until someone notices, finds the box and kills the process.
“Where did the work go?”
The box restarts and two hours of unpushed work vanish with it.
An example task, Fix refund rounding, routed to an isolated executor. Follow the pod from creation to deletion.
A step is routed to an isolated executor. ConvOps creates a Kubernetes Job for this run, mounts the task volume and a secret made for this run only.
The MCP servers the environment names start as sidecars inside the pod. Once they answer, the agent starts in the main container.
No service-account token. Non-root, every capability dropped, Pod Security restricted. No ingress, and no route into the rest of the cluster. Then the agent gets to work.
A clean fast-forward to the branch you named, or a task branch for review. Commits carry the identity you set on the environment.
If the run fails, nothing is thrown away. The commits go to a rescue branch, and the task volume is still there to resume.
The pod is deleted. What remains is the run record: tokens, model split, cost, turns, duration, and the error class if it failed.
One pod per run. Each part is there for a reason, and each one is gone when the run ends, except the work.
run pod · example
The working copy. Kept across the task's steps, so the next step and any resume pick up where this one stopped.
A Kubernetes Secret made for this run. Values are masked in every log and transcript.
MCP servers start as native sidecars before the agent, with per-tool allow and deny.
No service-account token is mounted. The agent cannot talk to the Kubernetes API.
Non-root, every capability dropped, under the Pod Security restricted profile.
No ingress at all. Egress to DNS, ConvOps and the internet, never the rest of your cluster.
Set per executor, 4 hours by default. The run cannot outlive it.
A clean fast-forward when history allows. A review branch when it does not. A rescue branch when the run fails.
Every executor has a time limit, 4 hours by default. Stop works on any run. A run that hits its limit waits for you to resume it.
You saw it heading the wrong way and pressed Stop. The pod ends and the run is recorded as stopped.
The run failed on an infrastructure error. A new run resumed on the same task volume on its own and finished without starting over.
Enterprise runs the whole system on its own Kubernetes. Runs, environments, secrets and records stay inside your cluster.
ConvOps cloud We run everything. Your AI clients and models stay yours and connect over MCP.
ConvOps runs in your Kubernetes from one Helm chart delivered with Enterprise. Runs are Jobs in a namespace you own.
Bring your own model provider and keys. Git access, secrets and MCP servers stay yours.
Code, secrets, transcripts and run records stay inside your cluster.
One Job per run. A fresh pod with no cluster credentials, no ingress and nothing from the run before.
one run, one pod
The working copy lives on a per-task volume. It outlasts the pod, so steps continue and runs resume.
kept across steps
MCP servers run beside the agent in the same pod, started first, with per-tool allow and deny.
native sidecars
A failed run keeps its work. The commits are pushed to a rescue branch you can pick up, and if that push fails the volume is held.
failure keeps the work
One Job per run. No service-account token, non-root, capabilities dropped, a deadline from the executor time limit, MCP servers as native sidecars (init containers with restartPolicy Always).
# run pod spec (example, trimmed)
apiVersion: batch/v1
kind: Job
metadata:
name: run-7f3a
namespace: convops-runs
spec:
backoffLimit: 0
activeDeadlineSeconds: 14400 # executor time limit
template:
spec:
automountServiceAccountToken: false
restartPolicy: Never
securityContext:
runAsNonRoot: true
seccompProfile: { type: RuntimeDefault }
initContainers:
- name: github-mcp # native sidecar
image: example/github-mcp
restartPolicy: Always
securityContext:
allowPrivilegeEscalation: false
capabilities: { drop: ["ALL"] }
containers:
- name: agent
image: example/agent-claude-code
securityContext:
allowPrivilegeEscalation: false
capabilities: { drop: ["ALL"] }
envFrom:
- secretRef: { name: run-7f3a }
volumeMounts:
- { name: task, mountPath: /work }
volumes:
- name: task
persistentVolumeClaim:
claimName: task-8c1eSelf-hosted installs set the run namespace, posture, network policy, time limit and model credentials in one values file for the Helm chart delivered with Enterprise.
# values.yaml (example)
runs:
namespace: convops-runs
podSecurity: restricted
networkPolicy:
ingress: none
egress: limited
timeLimit: 4h
taskVolume:
size: 10Gi
models:
existingSecret: model-credentialsEvery run pod is selected by a policy that admits nothing in, and lets out only DNS, ConvOps and the internet, never the rest of your cluster.
# run namespace network policy (example)
apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
name: convops-run-isolation
namespace: convops-runs
spec:
podSelector:
matchExpressions:
- { key: convops.neomanex.com/execution-id, operator: Exists }
policyTypes: [Ingress, Egress]
ingress: [] # no ingress at all
egress:
- ports: # cluster DNS
- { port: 53, protocol: UDP }
- { port: 53, protocol: TCP }
- to: # the internet, never the cluster
- ipBlock:
cidr: 0.0.0.0/0
except: [10.0.0.0/8] # your pod and service CIDRsWhen the pod is gone, the run record remains: tokens, per-model split, cost, turns, duration and the error class.
{
"task": "Fix refund rounding",
"executor": "isolated-sonnet",
"status": "succeeded",
"pushed": "convops/task/8c1e",
"tokens": { "input": 151200, "output": 30800 },
"models": { "sonnet": 0.91, "haiku": 0.09 },
"cost_usd": 1.94,
"turns": 34,
"duration_s": 700,
"outcome": "succeeded"
}ConvOps starts every isolated run as its own Kubernetes Job: a fresh pod with the task volume, a Secret made for that run only, no service-account token, Pod Security restricted and a network policy with no ingress. The pod is deleted when the run ends and the run record stays. Example: a nightly sanctions check and a code fix run side by side, each in its own pod.
No. ConvOps creates run pods without a service-account token, so the agent has no credentials for the cluster API. The pod runs as non-root, with every Linux capability dropped, under the Pod Security restricted profile. Example: a payroll run reads its own files and cannot list another team's pods.
ConvOps applies a NetworkPolicy to every run pod: no ingress at all, and egress only to DNS, ConvOps and the internet, never to the rest of your cluster. Your network plugin enforces it, so run on one that does. MCP servers the run uses can run as sidecars inside the same pod, so those calls never leave it.
ConvOps stores secrets once through a one-time link, never pasted in chat, or points at your own vault. Each run gets its own Kubernetes Secret, mounted for that run only, and the values are masked in every log and transcript.
Every ConvOps executor has a time limit (4 hours by default) and Stop works on any run. A run that hits its limit keeps its volume and is retried by hand: Resume on the same volume, or Start fresh. A failed run keeps its work on a rescue branch.
ConvOps deletes the pod when the run ends. The task volume stays so the next step continues from the same working copy. The run record stays too: tokens, model split, cost, turns, duration and any error class. Example: a month-end close keeps its working copy between the draft step and the review step.
Yes. Enterprise customers self-host ConvOps on their own Kubernetes from one Helm chart delivered with Enterprise. Runs, environments and secrets stay in your cluster, with your own models and credentials. Example: a bank keeps every transcript and run record inside its own cluster to meet its records policy.
Isolated ConvOps runs use Claude Code or OpenCode, in the main container with your environment around it. Work locally with any AI client that connects to ConvOps: the same workflows apply whichever client asks for the step. Example: a support team drafts replies with OpenCode in the pod while its lead works locally in Claude Code.