How Dolomite AI works.

Dolomite AI is an autonomous code maintenance platform built for modern software teams, agencies, and companies. You connect a GitHub repository, describe a maintenance task in plain English, and Dolomite runs an autonomous coding agent that inspects the repo, plans the work, edits code in a sandbox, runs checks, and prepares a pull request for your review.

It focuses on the maintenance layer after the first version is built: fixing bugs, repairing deployments, adding tests, wiring integrations, and cleaning up fast-moving or AI-generated codebases.

Every run follows the same loop:

1. Connect your GitHub repo and pick a branch.
2. Describe the task — title, description, and task type.
3. Dolomite indexes the project: files, dependencies, CI signals.
4. The agent selects a model strategy and routes each phase.
5. Code is edited inside an isolated, ephemeral sandbox.
6. Checks run: typecheck, tests, build, security scan.
7. A documented pull request is prepared for human review.

The agent proposes changes — it does not merge them. If a run would exceed its credit budget, it stops and reports back.

Dolomite Credits are the single unit of usage across the platform. Instead of managing API keys and invoices from multiple model providers, your workspace holds one credit balance. Every agent run shows estimated credits before it starts and actual credits used when it finishes.

Workspaces set a monthly budget and a per-run limit. Both are hard caps: the agent stops rather than overspending. Plans include a monthly credit allowance, and additional usage is billed in Dolomite Credits.

Dolomite does not depend on one model. Its internal model gateway routes each phase of a job to the model class best suited for that step: fast models for task classification, long-context models for repo understanding, premium coding models for complex changes, cost-efficient models for test generation, and verifier models for final review.

Model strategies (auto route, max quality, cost efficient, long context, enterprise policy) shape this routing, and workspace model policy controls which model classes are allowed at all. All provider calls go through Dolomite's backend — provider API keys are never exposed to frontend code or to the agent sandbox.

Dolomite AI can use OpenHands as one of its coding agent runtimes. OpenHands is not the user-facing product, billing system, or model provider. Dolomite AI manages workspace credits, model routing, provider calls, usage logs, and the product experience.

The full chain looks like this:

Frontend → Dolomite API → Agent Orchestrator
  → Coding Agent Runtime (e.g. OpenHands)
  → Internal Model Gateway → Providers
  → Usage Ledger → Billing

The runtime handles sandbox execution, file inspection, command execution, code editing, and test/build runs — and it calls the Dolomite Model Gateway for inference, so usage is always metered into Dolomite Credits.

Repositories connect through a Dolomite GitHub App with scoped, revocable permissions (Contents and Pull requests: read/write; Metadata: read). For each run the agent creates a branch named dolomite/{run-id}-{task}, commits its proposed changes, and opens a pull request with a summary and check results.

Nothing is pushed to your default branch. Your team reviews and merges like any other PR. In the current phase the mock runtime only ever commits a safe .dolomite/*.md test file, so a run can never alter application code.

To run the real GitHub loop locally: create a GitHub App (permissions: Contents read/write, Pull requests read/write, Metadata read-only), install it on a test repository, then copy its credentials into .env.local:

GITHUB_APP_ID=            # App ID
GITHUB_APP_CLIENT_ID=     # Client ID
GITHUB_APP_CLIENT_SECRET= # generated client secret
GITHUB_APP_PRIVATE_KEY=   # PEM (multiline or \n-escaped)
GITHUB_APP_WEBHOOK_SECRET=
GITHUB_APP_NAME=dolomite-ai
CODING_RUNTIME=mock

The full step-by-step guide lives in docs/development.md in the repository. Without a GitHub App the agent still runs in simulation mode — the full pipeline executes, but no pull request is created. Do not test against production repositories.

• Proposed changes are always reviewable — the agent prepares pull requests, humans merge them.
• Code runs in isolated, ephemeral sandboxes torn down after each task.
• Budget limits prevent runaway usage.
• Model policy controls keep usage aligned with company rules.
• Provider API keys live only in Dolomite's backend gateway — never in frontend code, never in the sandbox.

Dolomite is built to assist engineering judgment, not replace it. Security-critical changes should always get careful human review before merging.

• The coding runtime is a mock — it walks the real pipeline and opens real PRs, but only ever commits a safe .dolomite/*.md test file. OpenHands lands in a later phase.
• Model routing plans are generated locally from mock logic; no provider APIs are called yet.
• Credits are mocked (estimate 8.4, actual 3.2) — real numbers come from the Usage Ledger and Model Gateway later.
• Runs persist to a local JSON dev store; the Postgres schema ships in the repo for the future switch.
• No user authentication yet — everything runs as the dev workspace.
• Dolomite cannot fix every repo automatically, and it does not guarantee bug-free code — every change ships as a PR for review.

Ready to try the preview? Launch the Dolomite Agent →