Start with your environment.

Autocode is a Kubernetes controller for declarative coding tasks and persistent interactive workspaces in Eclipse Che. It prepares the environment around your agents and gives their work an explicit lifecycle.

Use a Task for a finite coding request. Use a Workspace for ongoing interactive development. Both select a reusable Agent, but each owns its own execution environment and session.

Prepare the platform first.

Autocode extends an existing Kubernetes and Che installation. Before deploying the controller or creating work, prepare:

• Eclipse Che and the DevWorkspace Operator. Use the platform prerequisites and validation scope documented for your target release. OpenShift Dev Spaces is the primary tested distribution.
• A provisioned workspace namespace. Associate it with the intended Che browser user, grant scoped access, and configure a restricted DevWorkspaceOperatorConfig.
• Persistent storage and workspace resources. Plan storage, requests, limits, and namespace quotas for the editor and agent tools.
• The selected tool providers. Install the exact registry provider/tag referenced by your Runtime or Environment into the administrator-managed Che AI Tool Registry.
• Private model configuration and authentication. Deliver credentials securely before launch. Tool injection does not supply model authentication or automatically share logins between Tasks.

Autocode does not install Che, replace the shared tool registry, or download missing agent CLIs. The installation guide is the authority for deployment commands and release-specific configuration.

Define your Agent once.

The configuration model separates execution behavior from workspace-wide tooling:

• Runtime defines launch commands, typed parameters, bootstrap, generated configuration, and completion behavior.
• Environment optionally supplies shared tools, utilities, files, editor resources, artifact sources, and MCP server definitions.
• Agent binds the Runtime and optional Environment to reusable values, defaults, and the intended Che browser identity.

ArtifactSources deliver skills, rules, hooks, and supporting files from supported sources. MCPServer declarations describe reusable HTTP or stdio connections; the Runtime renders them into native agent configuration.

Task and Workspace parameter overrides take precedence over Agent values and Runtime defaults. Referenced resources resolve within the requesting workload’s namespace. Version configuration deliberately rather than assuming edits will refresh an already running agent.

Submit a finite Task.

A Task selects an Agent, source repository and revision, instructions, and any supported overrides or policies. Prefer a full commit SHA when you need a reproducible source revision. The Task specification is immutable; changed instructions require a new Task.

The controller admits work according to priority and concurrency, prepares a dedicated DevWorkspace, and launches the configured agent. Status exposes the current phase, Conditions, workspace identity, deadlines, and bounded Git results.

Define what counts as done.

An observed successful process exit or authorized manual attestation provides completion evidence. The controller still evaluates your completion policy, which can require repository changes and a verified pull request.

In Agent mode, the agent manages commits, pushes, and PR creation. Optional Trusted mode uses an isolated helper for Git completion, keeping its GitHub credentials outside the workspace.

Decide what to retain.

Configure deadlines, retention, and TTL policies to suit the workload. Cancellation stops the matching Task session; detaching an editor viewer is not cancellation. Completion policy does not certify code correctness or replace tests and review.

Keep an interactive Workspace.

A persistent Workspace prepares the selected Agent’s environment for human-led development. Omit instructions to open a configured interactive shell, or provide instructions to opt into managed-agent launch.

Start and stop are explicit. Workspaces do not enter Task admission or consume Task concurrency slots, but Kubernetes quotas and platform resource policies still apply. Tasks never execute inside persistent Workspaces.

Attach without relaunching.

The delivered Che editor extension offers attachment to the existing shell or agent session. Detaching releases that editor’s viewer connection without stopping the session or other clients. Workspace trust and the intended user’s Che terminal access are required.

Persistent storage is not persistent process execution. Pod replacement loses processes and tmux sessions. Managed-agent recovery requires a compatible Runtime declaration and recorded native state; manually launched programs are not automatically replayed.

Delegate through MCP.

The optional semantic MCP service lets an external orchestrator discover configured resources, submit coding Tasks, inspect current state and result evidence, and request cancellation without receiving Kubernetes credentials.

With the authenticated interaction bridge configured, supported operations also expose bounded session output and follow-up input to a live Task. The service is deployed separately and requires reviewed authentication, TLS, namespace permissions, and gateway configuration.

This service orchestrates Tasks. It does not provide arbitrary pod exec, Secret access, or an alternative workspace scheduler. It is distinct from MCPServer resources that supply tools to agents inside their environments.

Go deeper.

The project’s technical guides cover exact commands, supported fields, deployment boundaries, and validation records. Repository access may be required.

• InstallationPlatform setup, controller deployment, optional services, and upgrades.
• Architecture and APIResource contracts, execution ownership, and trust boundaries.
• Artifacts and MCP serversContext delivery, target policies, and native server configuration.
• Platform validation recordsWhat was exercised for the relevant release and distribution.
• Security policySupported reporting and documented trust boundaries.