From a prompt to a live app

The application platform
built for AI coding agents.

Your agent writes the data model, the interface and the logic.
Sign-in, permissions, data APIs, storage and deployment are built in.

90%Built in: the platform

10%Custom code

DatabaseData APISign-inUser managementRoles and permissionsGit repoFile storageScheduled jobsEmailBillingDeploymentAI built inAI budgetsAudit logMCP toolsCustom domain

Data modelLogicUI

Why it matters

An agent that writes less has less to get wrong.

Reliable and secure

An agent cannot put a bug or a vulnerability into code it does not write. Sign-in, permissions and the data API are the platform, not generated.

Fast

Your app is production-ready in minutes, because the platform parts need no debugging.

Compounding

A fix or a feature in the platform reaches every app at once. Generated code has to be regenerated app by app.

What is built in

A complete application platform, ready to go.
No glue code, no separate services to wire up.

DatabaseA table for each thing your app stores

Data APIRead, write, filter and sort, for every table

Sign-inAccounts, sessions and password reset

User managementInvite people and see who has access

Roles and permissionsChecked by the platform on every request

File storageUploads and files your app keeps

Scheduled jobsWork that runs on a timer

EmailMail your app sends

BillingPlans and payments

DeploymentA live address, on every push

AI built inYour app calls AI through the platform, with no key of its own

AI budgetsA monthly cap on what each app may spend on AI

Usage meteringEvery operation is counted, so cost is known per app

Audit logA record of what happened, without wiring up logging

MCP toolsAgents can create, change, deploy and inspect the app through MCP

Git repoA real repository per app: clone it, push to it, read its history

Custom domainYour own web address, with the certificate issued for you

One data model in. A working backend out.

Define your data. Get the data API, sign-in and permissions.

In: your data model

Customer  name, email
Order     customer, total, status
Invoice   order, due date, paid

Out: a working backend

A table and an API for each
Sign-in, on
Private by default
Roles decide who sees and changes what

Your agent then writes the interface and your own logic against that API. There is no backend code to generate, review or debug.

More than hosting

Hosting and a database are included. The product is the application layer above them, which on any other stack your agent has to write.

	App builders	Hosting and backend services	Craftian
The application layer	Generated, new every time	Missing: your agent writes it	Built in
Sign-in and permissions	Generated too	Yours to assemble	Built in, the same under every app
Hosting and database	Usually not: bring your own	Included	Included, nothing to connect

Clear Access Control

A visual permissions matrix, enforced by the platform on every request. Not access rules scattered across generated code.

On Craftian

One table, checked on every request:

Role	View	Edit	Delete
Admin	yes	yes	yes
Editor	yes	yes	no
Viewer	yes	no	no

Without Craftian

Rules scattered across files of generated code:

routes/invoices.tsif (user.role === "admin") return true; // maybe?

components/EditButton.tsx{canEdit && <EditButton />}

api/delete.tsif (!isOwner(user, row)) deny(); // and admins?

Who can do what? Nobody can say without reading all of it.

Two ways in

Both produce the same kind of app on the same platform.

Your own coding agent

Claude Code, Cursor, Codex, OpenCode, Copilot or any other. It writes the app on your machine and pushes it with git. Describe your app at the top of this page to get a ready prompt.

Agent skill

The Craftian builder
Private beta

Describe the app in plain words and Craftian builds it for you, with no agent of your own. It is in private beta.

Your agent builds it. We run it on cloud.

Your machine

Your agent, your editor

local git history
nothing leaves while you build

Craftian cloud

Receives the code

validates the app model
attaches every service below
deploys to the edge

DatabaseSign-inPermissionsStorage and mailSchedules

Your linkhttps://your-tool.craftian.app

The path a request takes

Three journeys through the same machinery: the deploy you do once, every visit that follows, and the work that runs on a schedule while nobody is watching.

Once

You ship it

git pushFrom your machine, your editor, your agent.

DeployThe app is validated, its services attach, and it goes to the edge.

Live URLCertificate already issued. Nothing to point anywhere.

Every visit

Someone opens the link

VisitorA colleague, a customer, anyone you sent it to.

HTTPS at edgeNearest location. The certificate was issued for you.

Pages and assetsAnswered from the cache without waking anything.

Who is asking?Sign-in, roles and record permissions, checked here.

Your code, sandboxedNo filesystem and no direct network.

Its own dataBelonging to this app alone.

On a schedule

Nobody has to be watching

Cron firesEvery hour, every Monday, whatever you asked for.

Your code, sandboxedNo filesystem and no direct network.

Its own dataBelonging to this app alone.

Out through the gateMail, an API call, a webhook. Limited and counted.

Try it with no account

No accountNo password and no signing up. The token the first call hands back is the credential.
A whole appClone it and push to it with plain git, like any repository.
A day to decidePublish it or keep it with a free account. Walk away and it clears itself up after a day.

$ curl -X POST https://craftian.ai/git/new -d '{"name":"Todo App"}'
  { "appId": "todo-app-a3b4c1", "token": "TOK…", … }
$ git clone https://x:TOK…@craftian.ai/git/todo-app-a3b4c1.git
$ cd todo-app-a3b4c1
$ git add -A && git commit -m "the tool" && git push origin master
# no account so far. Publishing it is one more call, and a free account.

What your app gets the moment it lands

Not extras to buy, and not a pile of separate services to connect.
This is what is already waiting for your app, which is also the list of things nobody has to build again.

Delivery

How it reaches whoever opens the link

Frontend on the CDNPages, scripts and images served from the edge, near every visitor.

HTTPS, issued for youCertificates provisioned and renewed automatically.

A real web addressLive the moment it lands, on your own domain when you want one.

Runtime

Where your code actually runs

Backend APIYour routes, with each request checked before it runs.

Sandboxed executionNo filesystem, no direct network, hard time and memory limits.

Cron and scheduled jobsRecurring work runs on our clock. No machine to keep awake.

Outbound gateEvery call to the outside world is limited and counted in one place.

Identity

Who is asking, and what they may do

Sign-inAccounts for the people who use the app, not only for you.

Roles and permissionsPer role and per record type, enforced on the server every request.

State

What it keeps, and keeps apart

Its own databaseA database per app, not a shared table with your name in a column.

File storageUploads and generated files, isolated per app.

Encrypted secretsKeys live in a vault, never in the code and never in the repo.

In the open

What you can see, cap and keep

Usage and budgetsYou pay for what the app does, and you can cap the month.

Audit logA record of what happened, without wiring up logging.

A real git repoClone it, push to it, and read its history.

Setup is one line

Pick your tool and copy the line. It puts a small file in your project that tells your agent everything it needs to know about Craftian.

All agentsNo installClaude CodeCursorCodexOpenCodeCopilot

$npx skills add craftian-ai/craftian-skills -y

Installs the skill once for every agent in this project that reads skills. Run npx skills update to pick up new versions.

›Use https://craftian.ai/craftian-skill.md to create and deploy a new app. I will describe it.

Paste that into your assistant's chat. Nothing to install.

$npx skills add craftian-ai/craftian-skills -a claude-code -y

Lands as a project skill in .claude/skills/craftian/. Claude Code picks it up on its own.

$npx skills add craftian-ai/craftian-skills -a cursor -y

Lands in .agents/skills/craftian/. The description in the file tells Cursor when to use it.

$npx skills add craftian-ai/craftian-skills -a codex -y

Lands in .agents/skills/craftian/ and leaves your AGENTS.md exactly as it was.

$npx skills add craftian-ai/craftian-skills -a opencode -y

Lands in .agents/skills/craftian/, where opencode looks for skills.

$npx skills add craftian-ai/craftian-skills -a github-copilot -y

Lands in .agents/skills/craftian/, one of the folders Copilot reads skills from.

Open the skill file

Share it the way it deserves

A tool for the whole world and a tool for your team are different problems, so they are one setting apart.

Anyone can build anything

For a business, a side project, a community or a client. If it is built around data, it fits.

CRMMarketplaceBooking systemClient portal

CommunityJob boardDashboardTime tracker

Help deskInventoryContent siteLanding page

Frequently Asked Questions

Craftian is the application platform for apps written by coding agents. About 90% of what an app needs is the platform: a data API derived from the data model, sign-in, user management and role-based access control, plus storage, scheduled jobs, email, billing and deployment. Your agent writes only the 10% that is unique to your app.

Of the functionality a typical app needs, not of lines of code. The data API, sign-in, access control, user management, storage, scheduled jobs, email and deployment come from the platform. What is left for the agent is the data model, the app-specific logic and the interface.

No. Hosting and the database are included, and they are the convenience. The product is the application layer above them, which on any other stack the agent has to write: the API, the access control and the user management.

Any agent that can read a skill file and use git, including Claude Code, Cursor, Codex, OpenCode and Copilot. The agent writes the app on your machine and pushes it to Craftian with git.

Anything built around data: CRMs, marketplaces, booking systems, client portals, communities, job boards, dashboards, time and expense tracking, content sites and landing pages. Custom routes and custom backend code cover what the built-in API does not.

Our own app builder is in private beta. In the meantime, describe your app at the top of this page and you get a ready prompt to paste into your own coding agent, which builds the app and deploys it to Craftian.

Pricing is usage-based: you pay for what your apps consume, and an idle app costs nothing. There are Free, Pro and Business plans.

Public apps are accessible to anyone with the link. Restricted apps require sign-in and can have user permissions, which suits team tools and private applications.

Your app is deployed to our cloud when it is pushed. It gets its own web address, reachable worldwide, with HTTPS and hosting handled by the platform.

Ready to build something real?

Describe your app and have it live on Craftian in minutes.

Describe your app

The application platformbuilt for AI coding agents.