Your agents. Your environment.

AI coding agents, with the infrastructure behind them. Declarative tasks and persistent workspaces for Kubernetes and Eclipse Che.

  • Kubernetes native
  • Eclipse Che workspaces
  • Runtime-defined agents
  • MIT licensed

Delegate the task.
Or stay in the loop.

Some work has a finish line. Some needs room to explore. Autocode gives each its own lifecycle, using the same reusable agent configuration.

Finite Tasks

A clear brief.
A dedicated environment.

Declare a repository, revision, instructions, and Agent. Autocode prepares a task-owned workspace, launches the agent, and evaluates the result against your completion policy.

  • Immutable requests with pinned source revisions.
  • Startup and execution deadlines, priority, and concurrency control.
  • Git change and pull-request requirements, with recorded result evidence.
Understand Task lifecycles
Persistent Workspaces

A prepared workspace.
Ready for your next move.

Keep an interactive environment for ongoing development. Open a configured shell or opt into managed-agent launch, then start and stop the workspace explicitly.

  • Your tools, configuration, artifacts, and MCP connections prepared together.
  • Attach through the Che editor; detach without stopping the live session.
  • A separate lifecycle that does not consume a Task concurrency slot.
Explore persistent Workspaces

Separate by design: every Task owns its execution workspace. Tasks never run inside a persistent Workspace.

Configure the agent.
Not every request.

Separate how an agent runs from what its workspace contains. Bind a Runtime and optional Environment into a reusable Agent, then select it whenever you create a Task or Workspace.

Typed parameters, defaults, and per-request overrides let you adapt the work without duplicating the entire setup.

Meet the resource model
RuntimeLaunch, parameters,
and completion behavior
EnvironmentShared tools, files,
artifacts, and MCP servers
AgentReusable configuration and intended identity
TaskWorkspace
One configuration model. Two independent ways to work.

Bring the tools.
Bring the context.

An agent needs more than a prompt. Prepare the utilities, instructions, configuration, and connections that make it useful in your codebase.

Runtime profiles for

  • OpenCode
  • OMP
  • Codex
  • Claude

Selected tools and authentication must be provisioned for your installation.

Skills, rules, and hooks. Delivered.

Distribute agent context and supporting files from Git, OCI artifacts, ConfigMaps, inline content, or explicitly labeled Secrets. Target-path policies check where that content can land.

A shared environment, not a custom image.

Declare workspace-wide tools, bootstrap commands, generated files, and editor resources. Use installed Che AI Tool Registry providers without building a custom workspace image.

MCP connections in the agent’s own format.

Define HTTP or stdio MCP servers once. Environments select them; Runtimes render the configuration their agents expect, including approved Secret-backed values.

“The agent stopped”
isn’t a completion policy.

Define what counts as done. Autocode separates process completion from the Git result and the policy your Task must satisfy.

Completion evidenceProcess exit or
manual attestation
Result inspectionBranch, commits,
changes, and PR identity
Policy evaluationYour requirements.
An explicit outcome.

Require the result you need. Make repository changes or a verified pull request mandatory. Status records bounded Git evidence rather than trusting a URL printed by an agent.

Choose who handles Git. Leave commits and PRs to the agent, or configure trusted completion through an isolated helper that keeps its GitHub credentials outside the workspace.

Completion policy verifies declared result evidence. It does not replace tests, code review, or a decision to merge.

Your orchestrator.
Autocode’s execution.

Delegate coding work over MCP without handing your orchestrator Kubernetes credentials. The optional semantic MCP service exposes purpose-built task operations while the controller owns execution.

Understand MCP orchestration
  • DiscoverFind configured Agents, Runtimes, and Environments.
  • DelegateSubmit a bounded request with its source and policy.
  • Observe & steerRead current state and bounded output; send follow-up input to a live session.
  • Finish or cancelRetrieve result evidence or request cancellation.

Built for the people
who run the platform.

Work inside Kubernetes and Che’s existing boundaries, with explicit lifecycle controls and the operational context to understand what happened.

Control the workload.

Priority/FIFO admission, configurable concurrency, startup and execution deadlines, and bounded pre-launch retries keep finite work within declared limits.

See the current state.

Task conditions, workspace identity, timestamps, Git results, Kubernetes Events, and Prometheus metrics give operators concrete signals to investigate.

Keep boundaries explicit.

Namespace-scoped resources, Kubernetes RBAC, intended Che user access, and configurable retention keep ownership and cleanup tied to the workload.

Extends your platform. Doesn’t replace it.

Autocode uses an existing Eclipse Che installation and administrator-managed AI Tool Registry. OpenShift Dev Spaces is the primary tested distribution; check the documented validation scope for your target platform.

From platform to
productive workspace.

A deliberate setup path. No second tool registry, no mandatory custom workspace image, and no hidden hosted execution service.

  1. Prepare your platform.

    Set up Kubernetes, Eclipse Che, the DevWorkspace Operator, storage, namespace access, and the selected tool providers.

  2. Define your Agent.

    Choose a Runtime, add an Environment where needed, and provision model configuration and authentication securely.

  3. Choose how to work.

    Submit a Task with a clear goal and completion policy, or create a persistent Workspace for interactive development.

Read the prerequisites

A few things worth knowing.

Is Autocode a new coding agent?

No. Autocode is a Kubernetes controller that prepares environments and manages coding-work lifecycles. The selected Runtime defines how your agent is configured and launched.

Do I need Eclipse Che already installed?

Yes. Autocode uses an existing Che installation, the DevWorkspace Operator, and administrator-provisioned tools and workspace access. It does not install Che or replace the AI Tool Registry.

Can a Task use my persistent Workspace?

No. Each Task owns a separate execution workspace and session. Persistent Workspaces are for ongoing interactive work and have their own explicit start/stop lifecycle.

What happens when I close the editor?

Closing or detaching your viewer does not stop the existing live session. Stopping the Workspace or replacing its pod is different: running processes are not preserved, and native agent recovery requires explicit Runtime support and recorded state.

Does a successful Task mean the code is ready to merge?

Success means the configured completion policy was satisfied. It is not independent verification of code correctness, test results, or review approval. Keep your normal engineering checks and merge process.

Put your agents
in their environment.

Define the tools. Prepare the context.
Give the work a lifecycle you can control.

Get started