Use Cases
Dodil is where teams build real, production software fast — by driving the dodil CLI with Claude (or any agent). The platform is CLI-native and agent-native: a typed, reflection-discoverable API that a person and an AI agent can build against without guesswork, one identity across every service, and pipelines that handle the busywork. You describe what you want, let Claude drive the CLI, and ship it.
That changes how these applications get built. A support assistant, document extraction, semantic product search, an automation agent — each used to be a multi-week integration project stitched from separate vendors. On Dodil they’re a conversation with an agent that already knows how to call every piece.
How you build
Every service lives behind the same typed CLI, so building is the same motion each time: tell Claude the outcome, and it discovers the commands and wires them together.
- Drive the CLI — one binary (
dodil) reaches data, models, compute, and workflows. Typed commands, JSON output, nothing to glue. - Let an agent drive it — the same surface is exposed over MCP, so Claude can build against it directly, discovering commands by reflection instead of guessing.
- One identity — a single IAM token authenticates every service. No per-vendor credentials to wire through your code.
Why it ships faster than assembling the pieces yourself
Building and running a real application — not just an AI feature — normally means renting a dozen infra and SaaS vendors: object storage, a warehouse, a vector DB, an inference API, somewhere to run code, source control, CI/CD, a container registry, a workflow orchestrator, and auth wired through every one of them. Each is its own account, its own bill, its own integration to build and keep alive. Dodil consolidates the whole stack into one platform, one bill, one auth:
| What you need | Assemble it yourself | On Dodil |
|---|---|---|
| Object storage | S3 / GCS — its own account | K3 Objects |
| Structured data + SQL | A warehouse/DB (Snowflake, BigQuery, RDS) | K3 SQL |
| Vector search | Pinecone / Weaviate / Qdrant | K3 Vector |
| Graph / relationships | Neo4j / a graph DB | K3 Graph |
| Ingest → chunk → embed | Glue code or a pipeline tool | K3 pipelines (automatic on upload) |
| Embeddings + LLM | An inference API (OpenAI, Cohere) | Ignite Models (OpenAI/Cohere-compatible) |
| Running your code | Lambda / Fargate / k8s — pay for idle | Ignite Compute (serverless, scale-to-zero) |
| Source control + reviews | GitHub / GitLab / Bitbucket | Dodil Git (repos, PRs, reviews) |
| Build & CI/CD | GitHub Actions / CircleCI + a build pipeline | Dodil Git CI — build, test, push to Registry, deploy to Ignite |
| Container registry | Docker Hub / ECR / GHCR / Artifactory | Dodil Registry (CVE scan at push) |
| Workflow orchestration | Temporal / Airflow / Step Functions | Scriptum (typed, durable) |
| Identity across all of it | Wire auth into every service | One IAM token — works everywhere |
| Monitoring, scaling, upgrades | Per service, forever | One platform |
Collapsing that stack is where the wins come from:
- Faster to ship. One platform, one CLI, one auth, and pipelines that handle ingestion for you — features that take weeks to wire up land in days. The API is typed and reflection-discoverable, so people and agents build against it without guesswork.
- Cheaper to run. One vendor and one bill instead of a dozen vendors plus infra. No integration glue to build and maintain. Serverless compute with scale-to-zero means you don’t pay for idle. No cross-service ops tax.
- Less to break. Fewer moving parts and a single identity model mean a smaller surface to secure, monitor, and keep in sync.
The savings are structural — they come from removing vendors, glue, and idle capacity, not from a pricing gimmick.
What teams build
Each use case leads with the concrete outcome — who builds it and what it does in production — then maps it to the Dodil pieces you drive from the CLI.
- Enterprise software — rebuild the enterprise SaaS you rent (CRM, helpdesk, HRIS, ITSM, and more) as software you own — developed, built, deployed, run, and data-backed end to end on Dodil.
- Customer-support assistant — answer customers and agents from your own docs and tickets.
- Document intelligence — turn PDFs and contracts into structured, queryable data.
- Product & catalog search — semantic + keyword search that understands intent.
- Agentic automation — workflows that call tools and make LLM decisions, end to end.
See also
- Platform Design — how the pieces fit (RPC-first, one auth, agent-discoverable)
- The blog — full step-by-step walkthroughs of these builds