Skip to main content
Ottili Coder

Your software mission becomes a validated run

Describe your mission in plain language. Ottili Coder analyzes your repository, plans the work, builds a task queue, runs agents through validation loops, and ships via CLI, Desktop, or Ottili Cloud — with security checks throughout. Cloud runs are in beta and direct deployment is planned.

Start building
Beta
How it works

A brief becomes a durable run, not a dead-end prompt

Ottili Coder is built for the full loop: recon, planning, execution, validation, deployment, and review.

1

Describe your software mission

Start from Ottili ONE or the native Coder UI with your software mission, docs, repo context, deployment target, and project constraints.

2

Generate a real task queue

Ottili Coder inspects stack, dependencies, likely build paths, risks, and missing information, then creates a useful task queue instead of filler.

3

Run agents with validation

Tasks execute through role-based agents with local, cloud, or hybrid execution, plus logs, retries, validation loops, and failure states that stay visible.

4

Automate Git and deploy

Coder opens branches, commits, and prepares pull requests, then ships with deployment state, Security Check findings, and rollback kept on the same run.

Product preview

A look inside Ottili Coder — a run, clickable.

This interactive preview shows a real Coder run: repository analysis, plans, task queues, agents, validation loops, CLI, Desktop, cloud runs, deployment and security checks. Example data, not a live account; every step shows its honest status from the Ottili product registry — cloud runs are in beta and deployment is planned.

Chat-first experience

Drive every mode from a conversation

Ottili Coder is chat-first. You describe intent in plain language and watch the run form. These are the modes you can reach from the chat surface — each one shows what you see and what happens behind it.

Ottili Coder is chat-first. You drive every mode from a conversation — not by learning a new editor or IDE. The code surface is optional, not the product: describe intent, watch the run form, and steer it in plain language.

Ask

You see

Type a question in the chat — about a file, an error, a dependency, or how something works. Coder answers in context and cites the exact files and lines.

In the background

Coder reads your repository, builds a retrieval index over the current code, and grounds every answer in the codebase rather than generic model knowledge.

Plan

You see

Describe a goal in plain language. Coder returns a reviewable plan: recon findings, a task queue, and the risks it spotted before doing any work.

In the background

A planning agent inspects the stack, dependencies, likely build paths, and missing context, then decomposes the mission into editable tasks.

Build

You see

Say “build this” and watch the task queue fill in with agents, logs, and live status — no editor required to drive it.

In the background

Role-based agents (backend, frontend, infra, QA) execute tasks with retries and validation loops; every change is attributed and reversible.

Fix

You see

Paste an error or point at broken behavior. Coder explains the root cause and proposes a fix you can accept right in the chat.

In the background

A diagnosis agent reproduces the failure, isolates the cause, and re-runs validation loops until the failing path goes green.

Review

You see

Ask for a review of a branch or diff. Coder returns a plain-language summary of what changed and why it matters.

In the background

A review agent walks the diff, flags risk, security, and test gaps, and writes the summary back onto the run record.

Stabilize

You see

Ask Coder to harden a feature. It adds edge-case handling, tests, and explicit failure states, then shows the stabilization diff.

In the background

Agents extend coverage, tighten validation, and re-run the loop so stability work is measurable, not assumed.

Deploy

You see

Tell Coder where to ship. It prepares the deployment, shows status, and keeps rollback and audit on the same run.

In the background

Coder opens branches, commits, and pushes, then drives Docker-first or Ottili Cloud targets with health checks and rollback.

Full Run

You see

One command runs the whole loop: ask, plan, build, fix, review, stabilize, deploy — with a single report at the end.

In the background

The orchestrator chains the modes into one durable run, preserving logs, approvals, security findings, and deployment state end to end.

Queue, agents & validation

Inside an Ottili Coder run

A single mission travels through a queue, isolated agents, approval gates, live logs, tests, real artifacts, retries, and a validated final result. This is the loop behind every Coder run.

Every mission becomes a durable run. Below is the queue, agent, and validation workflow Ottili Coder follows — from your plain-language brief to a validated, deployable result.

  1. Step 1Mission
  2. Step 2Task queue
  3. Step 3Isolated work
  4. Step 4Agents
  5. Step 5Approvals
  6. Step 6Logs
  7. Step 7Tests
  8. Step 8Artifacts
  9. Step 9Retries
  10. Step 10Final result

Example run

Add OAuth login to the dashboard

Beta
  1. Recon & stack analysisanalystDoneLogs captured
  2. Scaffold OAuth routesbackendDoneTests passed
  3. Fix callback handlerbackendRetriedRetried 1× → passed
  4. Security gatesecurityApprovedApproval recorded
  5. Deploy to staginginfraApprovedApproval required → approved
  6. Open pull requestgitArtifactPR #482 created
Final result:branch feat/oauth-login·PR #482·deployed to staging, rollback & audit on the same run

Step 1

Mission input

You see

You describe the software mission in plain language — goals, repo context, constraints, and a deployment target.

Behind the scenes

Coder captures the mission as a durable run record, not a disposable chat message, so every later step stays traceable to your original intent.

Step 2

Generated task queue

You see

The mission expands into a reviewable task queue — recon, planning, and decomposition — that you can edit before anything runs.

Behind the scenes

A planning pass inspects the stack, dependencies, likely build paths, risks and missing context, then decomposes the mission into ordered, individually-runnable tasks.

Step 3

Isolated execution

You see

Each task runs in its own isolated workspace; you see a clean separation between tasks instead of one tangled working tree.

Behind the scenes

Work happens in disposable, sandboxed environments with no cross-task state bleed, so a failure in one task cannot corrupt the output of another.

Step 4

Role-based agents

You see

Specialist agents pick up tasks: analyst, backend, frontend, infra, QA, security, docs and UX.

Behind the scenes

The orchestrator fans tasks out to agents by role, tracks ownership for every change, and keeps each agent's contribution attributable on the run.

Step 5

Approval gates

You see

Risky or externally-visible steps pause and wait for a human approval before they proceed.

Behind the scenes

Approval gates hold deployments, destructive actions and external calls until a person confirms, and the decision is recorded on the run record.

Step 6

Live logs

You see

Live logs stream per task and per agent as the work happens, so you never lose the thread of what changed.

Behind the scenes

Every command, decision and artifact write is captured with ownership and timestamps, keeping the run auditable long after it finishes.

Step 7

Validation and tests

You see

Validation gates show a clear pass or fail per task: type checks, the test suite, and security checks.

Behind the scenes

Each task must clear automated validation — type checks, the test suite and security gates — before it is marked done and handed onward.

Step 8

Artifacts

You see

Finished tasks produce real artifacts: branches, commits, pull requests, and the changed files behind them.

Behind the scenes

Coder opens branches, commits, and prepares pull requests from agent output; every artifact is reviewable, attributable and reversible.

Step 9

Retries with explicit failure

You see

When a task fails a gate, you see it retry with an explicit failure state — not a silent dead end.

Behind the scenes

Coder retries transient failures with backoff and surfaces a clear failure reason; only after retries are exhausted does a task stop with a reported error.

Step 10

Final result

You see

The run ends with a single result — deployed or handed back — with status, rollback and audit on the same record.

Behind the scenes

Passing runs deploy to Docker-first targets; Ottili Cloud deployment is planned, not yet a public destination. Deployment status, rollback and the full audit trail stay on the run record.

Concrete workflow

A run, step by step — from repository to deployment

See the actual Ottili Coder surface: repository analysis, a plan, a task queue, role-based agents, validation loops, then execution via CLI, Desktop or cloud runs, and deployment — with security checks throughout. Every step shows its honest readiness status from the Ottili product registry; cloud runs are in beta and direct deployment is planned, never claimed as live.

How an Ottili Coder run works

From a chat brief to a validated, deployable result — the software-automation surface of Ottili ONE.

  1. Live
    Repository analysisOttili Coder
  2. Live
    PlansOttili Coder
  3. Live
    Task queuesOttili Coder
  4. Live
    AgentsOttili Coder
  5. Live
    Validation loopsOttili Coder
  6. Live
    CLIOttili Coder
  7. Live
    DesktopOttili Coder
  8. Beta
    Cloud runsvia Ottili Cloud
  9. Planned
    Deploymentvia Ottili Cloud

Around the run

  • Native to Ottili ONELive
    native to Ottili ONE

How Ottili Coder handles your code

Company-scoped, validation-first, audited and security-checked — the data-handling guarantees behind every Ottili Coder run.

  1. Live
    Company-scoped repository accessvia Ottili Core
  2. Live
    Plan review before executionvia Ottili Console
  3. Live
    Validation loopsOttili Coder
  4. Live
    Ottili Security Checkvia Ottili Core
  5. Planned
    Deployment approvalvia Ottili Console
  6. Live
    Audit trailvia Ottili Core

Around the run

  • Repository analysisLive
    Ottili Coder
  • PlansLive
    Ottili Coder
  • Task queuesLive
    Ottili Coder
  • AgentsLive
    Ottili Coder
  • CLILive
    Ottili Coder
  • DesktopLive
    Ottili Coder
  • Cloud runsBeta
    via Ottili Cloud
  • Native to Ottili ONELive
    native to Ottili ONE
Feature overview

Everything a run touches, grouped

The same Coder surface — repository analysis, plans, task queues, agents, validation loops, CLI, Desktop, cloud runs, deployments and security checks — grouped by what they do. Every item carries its honest readiness status from the Ottili product registry; cloud runs are in beta and direct deployment is planned, never claimed as live.

Plan, queue and run

  • Live
    Repository analysisOttili Coder
  • Live
    PlansOttili Coder
  • Live
    Task queuesOttili Coder
  • Live
    AgentsOttili Coder
  • Live
    Validation loopsOttili Coder
  • Planned
    Deploymentvia Ottili Cloud

CLI, Desktop and cloud runs

  • Live
    CLIOttili Coder
  • Live
    DesktopOttili Coder
  • Beta
    Cloud runsvia Ottili Cloud
  • Live
    Native to Ottili ONEnative to Ottili ONE

How Ottili Coder handles your code

  • Live
    Company-scoped repository accessvia Ottili Core
  • Live
    Plan review before executionvia Ottili Console
  • Live
    Validation loopsOttili Coder
  • Live
    Ottili Security Checkvia Ottili Core
  • Planned
    Deployment approvalvia Ottili Console
  • Live
    Audit trailvia Ottili Core
Capabilities

Built for usable execution, not demo theater

Ottili Coder joins chat-first planning, run orchestration, automated Git, validation, security, and deployment into one product surface.

Software mission input

Live

Start from a chat-first brief: describe your software mission in plain language — goals, repo context, constraints, and deployment target. Coder turns the mission into a structured, reviewable task queue instead of a dead-end prompt.

Planning and task generation

Live

Coder inspects the stack, dependencies, likely build paths, risks, and missing information, then generates a real task queue — with recon, planning, and decomposition you can edit before execution begins.

Dynamic agent execution

Beta

Runs fan out across analyst, backend, frontend, infra, QA, security, docs, and UX roles. Agents work locally, in the cloud, or hybrid while logs, ownership, and validation stay visible.

Validation loops

Live

Every task runs through validation loops with retries and explicit failure states. Tests, type checks, and security gates must pass before a task is marked done and handed to deployment.

Automated Git

Live

Coder opens branches, commits, pushes, and prepares pull requests from agent output. Every change is reviewable, attributable, and reversible, with a clean Git history per run.

Local, cloud & hybrid execution

Beta

Choose where work runs: on your machine, in Ottili Cloud, or a hybrid of both. The same task queue, logs, and validation behave consistently across every execution mode.

Validation and deployment

Planned

Passing runs deploy to Docker-first targets, with deployment status, rollback, and audit trails kept on the same run record. Ottili Cloud deployment is planned, not yet a public destination.

Ottili Security Check

Live

Dependency and secret risk reviews flow into the same task system so outdated or risky packages can be triaged, fixed, validated, and audited.

Feature status

What is available on Ottili Coder — honest, registry-backed

Every capability below carries a feature status from the canonical Ottili product registry. Nothing here claims an availability the registry does not attest — repository analysis, plans, task queues, agents, validation loops, CLI, Desktop and security checks are available, cloud runs are in beta, and direct deployment is planned until the public destination is wired.

Repository analysis

Live

Ottili Coder inspects your stack, dependencies, build paths, risks and missing information before generating any work (available).

Ottili Coder

Plans

Live

Coder turns a mission into a structured, reviewable plan before any execution (available).

Ottili Coder

Task queues

Live

Coder generates a real, editable task queue that agents execute (available).

Ottili Coder

Agents

Live

Runs fan out across role-based agents — analyst, backend, frontend, infra, QA, security, docs and UX (available).

Ottili Coder

Validation loops

Live

Every task runs through validation loops with retries and explicit failure states (available).

Ottili Coder

CLI

Live

Drive the same mission, task queue, logs and validation from the Ottili Coder CLI (available).

Ottili Coder

Desktop

Live

Run Coder from the native Ottili Coder Desktop app for Windows, macOS and Linux (available).

Ottili Coder

Cloud runs

Beta

Cloud runs execute the same task queue in Ottili Cloud so you do not tie up local machines (beta).

Ottili Cloud

Deployment

Planned

Direct Ottili Cloud deployment is planned until the public destination is wired; the page shows the honest planned status (planned).

Ottili Cloud

Security checks

Live

Ottili Security Check reviews dependency and secret risk into the same task system (available).

Ottili Core

Security & data handling

How Ottili Coder keeps your code inside your company

Ottili Coder analyzes repositories, builds plans, generates task queues, runs agents, validates every change, and prepares deployment — all inside one company boundary. The guarantees below carry their honest status from the canonical Ottili product registry: company-scoped repository access, plan review, validation loops, Ottili Security Check, deployment approval and audit. Cloud runs are in beta and direct deployment is planned, never claimed as live.

Security & data handling

Your code stays inside your company

Ottili Coder analyzes repositories, builds plans, generates task queues, runs agents, validates every change, and prepares deployment — all inside one company boundary. Every guarantee below carries its honest status from the Ottili product registry; nothing claims a certification or standard we have not verified. Cloud runs are in beta and direct deployment is planned until the public destination is wired.

  • Live
    Company-scoped repository accessvia Ottili Core
  • Live
    Plan review before executionvia Ottili Console
  • Live
    Validation loopsOttili Coder
  • Live
    Ottili Security Checkvia Ottili Core
  • Planned
    Deployment approvalvia Ottili Console
  • Live
    Audit trailvia Ottili Core
  • Live
    Repository analysisOttili Coder
  • Live
    PlansOttili Coder
  • Live
    Task queuesOttili Coder
  • Live
    AgentsOttili Coder
  • Live
    CLIOttili Coder
  • Live
    DesktopOttili Coder
  • Beta
    Cloud runsvia Ottili Cloud
  • Live
    Native to Ottili ONEnative to Ottili ONE

What this means for your runs Repository access is company-scoped, plans are reviewed before execution, and Ottili Security Check reviews dependency and secret risk into the same task system. Deployment is approval-first and every action is recorded through Ottili Core audit. Security checks are available; deployment approval stays planned until verified.

Pricing & availability

What Ottili Coder costs and what is available today

The availability half below is driven by the canonical Ottili Coder feature-status registry — every capability carries its honest readiness status (cloud runs in beta, direct deployment planned, never claimed live). The pricing half is sourced from the central Ottili ONE plan catalog; AI usage is credit-based and bounded, with no unlimited expensive agentic inference. When a grounded price is not yet published, the section shows its honest empty state rather than a fabricated figure.

Availability

What is available in Ottili Coder today

Every capability below is a real Ottili Coder capability with its honest readiness status. Availability comes from the Ottili product registry — nothing is shown as available that is not. Cloud runs are in beta and direct deployment is planned, never claimed as live.

  • Repository analysis

    Live

    Ottili Coder inspects your stack, dependencies, build paths, risks and missing information before generating any work (available).

    Ottili Coder

  • Plans

    Live

    Coder turns a mission into a structured, reviewable plan before any execution (available).

    Ottili Coder

  • Task queues

    Live

    Coder generates a real, editable task queue that agents execute (available).

    Ottili Coder

  • Agents

    Live

    Runs fan out across role-based agents — analyst, backend, frontend, infra, QA, security, docs and UX (available).

    Ottili Coder

  • Validation loops

    Live

    Every task runs through validation loops with retries and explicit failure states (available).

    Ottili Coder

  • CLI

    Live

    Drive the same mission, task queue, logs and validation from the Ottili Coder CLI (available).

    Ottili Coder

  • Desktop

    Live

    Run Coder from the native Ottili Coder Desktop app for Windows, macOS and Linux (available).

    Ottili Coder

  • Cloud runs

    Beta

    Cloud runs execute the same task queue in Ottili Cloud so you do not tie up local machines (beta).

    via Ottili Cloud

  • Deployment

    Planned

    Direct Ottili Cloud deployment is planned until the public destination is wired; the page shows the honest planned status (planned).

    via Ottili Cloud

  • Security checks

    Live

    Ottili Security Check reviews dependency and secret risk into the same task system (available).

    via Ottili Core

Pricing

Pricing for Ottili Coder

Ottili Coder follows the same plans as Ottili ONE. Plan prices come from the central pricing catalog; AI usage is credit-based and bounded, with no unlimited expensive agentic inference.

Pricing is sourced from the central Ottili ONE pricing source. AI usage is credit-based and bounded; there is no unlimited expensive agentic inference. You are never charged without explicit confirmation.

Execution modes

Local, cloud, and hybrid — choose where work runs

The same task queue, validation, approvals, and audit trail follow the run whether it executes on your machine, in Ottili Cloud, or a mix of both. Here is what each mode requires, how data moves, and what is available today.

Ottili Coder runs the same task queue in three execution modes. The orchestration, logs, validation, and audit trail are identical no matter where the work happens — only the runner changes.

Local execution

Live

You see

Code and agents run on your own machine through the Coder CLI or desktop app. Source stays in your environment; only the run metadata needed for identity, credits, and audit leaves it.

In the background

The local runner pulls tasks from your Ottili run queue, executes each in an isolated workspace, streams logs back, and pushes artifacts (branches, commits, pull requests) through your own Git.

Cloud execution

Beta

You see

Ottili provisions a managed remote runner for you. Your repository and task context are sent to a cloud workspace, and results return to the same run record.

In the background

Cloud runs are in beta: capacity is limited and credit-metered, behavior may change, and it is not intended for production secrets without review. Availability is shown on the public status page.

Hybrid execution

Beta

You see

Plan and run lightweight tasks locally, then hand long-running or compute-heavy work to a cloud runner — all on the same run, with one coherent queue.

In the background

The orchestrator keeps a single queue; execution location is a per-run or per-task choice, so local and cloud tasks interleave on one record. Hybrid depends on cloud runs, so it carries the same beta maturity.

Runner requirements

  • Git, with read/write access to the repository you want Coder to work in.
  • A runtime for the work: the Coder desktop app or a container runtime such as Docker.
  • Node.js and Python for the runtimes Coder drives during a run.
  • An Ottili account with Coder enabled — this supplies identity, credits, and the run queue.
  • Network access to Ottili for authentication, queue sync, credit accounting, and audit.
  • Optional: MCP servers and provider credentials for the specific task you are running.

The ottili-coder doctor command checks these before a run starts.

How data flows through a run

  1. Mission input becomes a durable run record, not a disposable chat message.
  2. Planning expands the mission into a reviewable task queue (recon, decomposition, risk).
  3. Execution runs agents in isolated workspaces — locally, in the cloud, or hybrid.
  4. Validation gates each task: type checks, the test suite, and security checks must pass.
  5. Artifacts are produced through your Git: branches, commits, and pull requests.
  6. The record closes with logs, approvals, status, and the audit trail kept on the same run.

Permissions and your data

  • Authenticated through your Ottili identity (“Sign in with Ottili”).
  • Access follows your company and role model; approval gates hold risky or external steps.
  • Local runs keep source on your machine; cloud runs send repo context to a managed workspace.
  • An audit trail (who, what, when) stays on the run record in every mode.

Offline limitations

  • Coder is not fully offline: the local runner still needs Ottili connectivity for auth, credits, queue sync, and audit.
  • Cloud runs additionally require network access to the cloud workspace.
  • Secrets are resolved through Ottili at execution time; they are not stored in plain text on the runner.

Cloud availability

  • BetaCloud runs — in beta: limited capacity, credit-metered, subject to change.
  • PlannedCloud deployment — shipping a run result to Ottili Cloud infrastructure is planned and is not yet a public destination. It is not presented here as available.

Current Coder service status (Web, Cloud Runtime, CLI Services, GitHub Integration) is published on the public status page.

Creator suite

Start from websites, landing pages, WordPress, or deployable briefs

Creator is the product entry point for teams who need a result, not just a repository assistant.

Creator to run bridge

Saved website projects can move into the run engine with source-project context preserved on the run.

  1. 1Capture project goals, audience, pages, and design direction
  2. 2Store deployment target and Creator brief in a durable project record
  3. 3Open the run builder or queue a Creator-backed execution run
  4. 4Track linked runs, deployments, and validation history in one place

Delivery surfaces

Ottili Coder supports both native Coder usage and Ottili ONE-backed platform services behind the scenes.

  1. 1Native Ottili Coder UI for project and run management
  2. 2Shared Ottili ONE auth, company, billing, and credits
  3. 3Deployment tracking for Docker-first workflows
  4. 4Ottili Cloud deployment (planned, not yet available)
Install Ottili Coder

Run Ottili Coder on desktop or from the CLI

Get the native desktop app for Windows, macOS, and Linux, or drive runs from the command line. The install surface publishes supported systems, the current version, checksums, prerequisites, update behavior, and an honest status for every platform — with documentation fallbacks when an artifact is not yet published.

Install desktop appCLI documentation
Verifiable proof

What Ottili Coder actually is — proven, not claimed

Ottili Coder shows its current public release status, a public source repository you can inspect, and a validated workflow. The workload figures are clearly labeled internal examples, never customer adoption.

Ottili Coder, proven

Verifiable proof — not marketing claims

We show what Ottili Coder actually is: its current public release status, a public source repository you can inspect, and a validated workflow. The workload figures below are clearly labeled internal examples, not customer adoption.

Current release status

Beta

Public beta status from the Product Truth registry.

Public source repositoryBrowse the public Ottili source code and examples.Publicly verifiableLive Ottili CoderThe current Ottili Coder release, running in public beta.Publicly verifiableValidated example runSee the documented example run (PR #482) with approval gates and audit.Publicly verifiable

Internal workload metrics

Internal example metrics — derived from the public Example run (PR #482) and the documented execution model. These show the shape of a Coder run. They are NOT live customer counts or adoption.

6

Tasks in the example run

From the public Example run (PR #482) on this page — not a live total.

Internal · not customer adoption

2

Approval gates held

Approval gates held in the public Example run (PR #482).

Internal · not customer adoption

3local · cloud (Beta) · hybrid

Execution modes available

Modes you can choose today; cloud runs are in Beta.

Internal · not customer adoption

3type · test · security

Validation gates per task

Every task must clear type checks, tests and the security gate.

Internal · not customer adoption
Pricing

Coder pricing, sourced from central Ottili ONE plans

Ottili Coder follows the same plans as Ottili ONE. The summary is connected to the central pricing source and distinguishes free access, credits, cloud execution, and paid value — with no unlimited expensive inference.

Free

Free ForeverLive

€0

Free forever. The Ottili ONE dashboard, core workspace and essential everyday operations stay free — no credit card, no expiry. Cost-generating and high-value features (advanced AI execution, Ottili Coder, LD3, API access, high-volume automation) run on paid plans or credits.

  • Ottili Coder not included
Start free

Starter

Live

€39/mo

Base subscription for small teams starting with operations workflows.

  • Ottili Coder not included
  • 500 AI credits / month
Start with Starter
Most popular

Pro

Live

€299/mo

Advanced plan for automation, engineering and AI-assisted operations.

  • Ottili Coder included
  • 5,000 AI credits / month
Start with Pro

Business

Live

€499/mo

Full operating plan for multi-team commerce, content, AI and engineering.

  • Ottili Coder included
  • 25,000 AI credits / month
Contact sales
Live

Free platform access

The Free plan opens the Ottili ONE dashboard and core features. Ottili Coder is not included on Free — Coder begins on the Pro plan.

Live

Credits, not unlimited inference

Every use is metered through Ottili AI credits. There is no unlimited free agentic inference — you keep cost control through your credit budget.

Beta

Cloud execution (Beta)

Coder runs can execute locally, in Ottili Cloud, or hybrid. Cloud runs are in Beta; cloud deployment itself is Planned, not yet a public destination.

Live

Paid value from Pro

From the Pro plan, Ottili Coder and Ottili AI are included, with more credits on higher plans. You are only charged after explicit confirmation — no hidden fees.

Pricing is sourced from the central Ottili ONE pricing source. AI usage is credit-based and bounded; there is no unlimited expensive agentic inference. You are never charged without explicit confirmation.

Selected plan: Pro · €299/mo

What every Coder plan includes — Included · Credit-metered (bounded by Ottili AI credits) · Planned · Not included

Local executionLive
Run Coder on your own machine with the same task queue, validation and audit trail as cloud runs.
Included
Cloud executionBeta
Execute runs in Ottili Cloud or hybrid. Cloud runs are in Beta; cloud deployment is planned.
Included
Software missionsLive
Describe a mission in plain language; Coder turns it into a structured, reviewable task queue.
Credits
Concurrent runsBeta
Run multiple missions concurrently. Metered through Ottili AI credits — bounded by your credit budget.
Credits
Dynamic agentsLive
Role-based agents (analyst, backend, frontend, infra, QA, security, docs, UX) fan out across execution modes.
Credits
AI creditsLive
Every AI action is metered through Ottili AI credits. You keep cost control through your credit budget.
Included5,000 credits / month
Repository analysisLive
Coder inspects stack, dependencies, build paths, risks and missing information before planning.
Included
Cloud deploymentPlanned
Ship passing runs to Docker-first targets. Ottili Cloud deployment is planned, not yet a public destination.
Planned
Security checksLive
Dependency and secret risk reviews flow into the same task system and are triaged, fixed and audited.
Included
Run analyticsLive
Track runs, agents, validation, security findings and outcomes on the same run record.
Included
Team controlsLive
Roles, permissions, shared workspaces and audit trail follow the plan's team membership.
Included

Included · Credit-metered (bounded by Ottili AI credits) · Planned · Not included

Pricing is sourced from the central Ottili ONE pricing source. AI usage is credit-based and bounded; there is no unlimited expensive agentic inference. You are never charged without explicit confirmation.

Pricing is sourced from the central Ottili ONE plan registry; no divergent or invented figures.

FAQ

Questions about Ottili Coder

Answers on repository analysis, plans, task queues, agents, validation loops, CLI, Desktop, cloud runs, deployments and security checks — without claiming availability we cannot back up.

The Ottili Coder questions are not configured yet.

Documentation

Read the Ottili Coder docs

Public references for the Coder surface — repository analysis, plans, task queues, agents, validation loops, CLI, Desktop, cloud runs, deployments and security checks. Documentation never exposes private backend routes or internal credentials (website audit P0.2).

Ready to launch

Use Ottili Coder

Open Ottili Coder as its own product or inside Ottili ONE — the same queue, agents, validation loops, Git, Security Check, and audit trail power both. Cloud runs are in beta and direct deployment is planned.

Create workspaceBetaOpen Ottili Coder