# Your agent makes the calls. We run everything under it.

> [llms.txt](https://staging.judt.ai/llms.txt) lists this site's pages, Judt's docs, and the ways an agent can get access.

Watch an agent take an App from the first file to a live address. These are the calls it makes, and what every App comes with.

[Start free](https://staging.judt.ai/signup)

Four sessions, call by call. Our own agent makes the same calls.

### Hiring tracker

> Make an applicant tracker for Acme: a form for candidates and a board for the team.

- `list_templates`: 8 templates
- `create_app`: from saas-starter
- `write_file`: src/routes/apply.tsx
- `write_file`: src/routes/board.tsx
- `run_command`: npm run build
- `create_preview`: ready
- `deploy`: succeeded

The tracker is live at acme-hiring.judt.dev. Your team signs in with email. Candidates apply at /apply.

### Sales dashboard

> Every Monday, chart last week’s pipeline and share it with the sales team.

- `create_app`: from tanstack-start
- `request_secrets`: WAREHOUSE_URL
- `write_file`: src/routes/index.tsx
- `write_file`: wrangler.json: Mondays 9:00
- `run_command`: npm run build
- `create_preview`: ready
- `deploy`: succeeded

acme-pipeline.judt.dev updates every Monday at 9:00 and posts a summary to #sales.

### Slack agent

> Build a Slack agent that files Jira tickets from #support and replies in the thread.

- `create_app`: from api-router
- `write_file`: src/agent.ts
- `request_secrets`: SLACK_BOT_TOKEN, JIRA_TOKEN
- `run_command`: npm run build
- `create_preview`: ready
- `deploy`: succeeded

The agent is live at support-agent.judt.dev. Point your Slack app’s events at /slack/events.

### Café website

> Build a website for Northwind Café: the menu, opening hours and a catering form.

- `list_templates`: 8 templates
- `create_app`: from remix-cafe
- `write_file`: app/menu.ts
- `write_file`: app/routes/home.tsx
- `run_command`: npm run build
- `create_preview`: ready
- `deploy`: succeeded

Northwind Café is live at northwind-cafe.judt.dev. Catering requests go to the inbox at /admin.

## Every App, batteries included.

Each App has its own infrastructure so you can accomplish big things. Your agent controls it all over MCP or API.

- **Address**: acme-hiring.judt.dev, or your own domain
- **Code**: Your pages, API routes and agent code
- **Database**: SQLite, relational storage
- **Storage**: Uploads, documents, images and large data
- **Durable Objects**: Live state for chat rooms and agent sessions
- **Schedules and queues**: Cron jobs and background work
- **Workflows**: Steps in order, with waits of hours or days

## Made for agents to use.

Judt is fully headless, designed to be used by agents. Sure, you can use the dashboard too, but we don't expect you to.

### One API for every step

Create, write, preview, publish and restore an earlier version. Connect with MCP, the API or the CLI.

`POST /api/apps/{id}/deployments`

```json
200 OK
{
  "id": "dep_8Hq2…",
  "status": "succeeded",
  "published_at": "2026-10-28T09:22:41Z"
}
```

### Errors it can fix

If something fails, your agent gets the context to fix it. Query logs or events to see and fix issues.

`POST /api/apps/{id}/preview`

```json
422 Unprocessable Content
{
  "error": {
    "code": "preview_failed",
    "message": "The App's dev server failed to build or start",
    "detail": "Could not resolve \"hono/jsx\"…"
  }
}
```

### Logs from every run

Requests, console output and crashes, from the preview and the live App.

`GET /api/apps/{id}/logs?level=error`

```json
200 OK
{
  "results": [{
    "environment": "production",
    "source": "app",
    "level": "error",
    "message": "ReferenceError: board is not defined"
  }],
  "has_more": false
}
```

- **Skills baked in**: Skills that are ready to go
- **Secure hosting**: We run your App on our own infrastructure, with TLS and DDoS protection.
- **Your model or ours**: Bring your own agent and tokens, or hand the whole task to ours.

### Connect with the API, MCP or the CLI.

#### API

Clean and clear API for managing Apps. Judt is a fully headless platform, built for developers and agents.

`api.judt.ai` · Available

Create an App:

```bash
curl https://api.judt.ai/api/apps \
  -H "Authorization: Bearer $JUDT_TOKEN" \
  -d '{"name": "Acme hiring"}'
```

```json
200 OK
{
  "id": "app_…",
  "url": "https://acme-hiring.judt.dev"
}
```

#### MCP

Add the MCP server to your agent and it gets the same tools our agent uses: write files, run commands, preview and publish. It even has logs to debug.

`api.judt.ai/mcp` · Available

mcp.json:

```json
{
  "mcpServers": {
  "judt": {
    "url": "https://api.judt.ai/mcp",
    "headers": {
      "Authorization": "Bearer ${JUDT_TOKEN}"
    }
  }
  }
}
```

#### CLI

Use Judt from any shell, you or your agent. Each command is one API call, and --help explains every one.

`judt` · Available · [CLI docs](https://docs.judt.ai/manage/cli)

Terminal:

```shellsession
$ curl -fsSL https://judt.ai/install | sh
$ judt auth login
$ judt apps create --name "Acme hiring"
$ judt apps files write index.js --content @index.js
$ judt apps preview
$ judt apps deploy
```

## Start from a working App.

A template gives your agent an App that already runs. It spends its tokens on what makes your App different, not on sign-in pages and database setup.

- **Fewer tokens**: Changing a working App costs less than writing one from an empty folder.
- **Best practices built in**: Sign-in, migrations, forms and feeds come set up and tested.

- **Remix Café**: A website for a café, with a menu, opening hours and a catering form. Starts with: Database, Sign-in.
- **Blog**: Posts, search, cover images and feeds, with a Markdown editor. Starts with: Database, Storage, Sign-in.
- **SaaS Starter**: Sign-up, workspaces, roles, invitations and a projects dashboard. Starts with: Database, Sign-in.
- **Realtime Chat**: Channels with live messages, presence and typing. Starts with: Database, Durable Objects, Sign-in.
- **Pi Agent**: A personal AI agent you can text on WhatsApp, iMessage or SMS. Starts with: Storage, Durable Objects, Sign-in.
- **TanStack Start**: A full-stack React App with server functions and a JSON API. Starts with: Database.
- **API Router**: A JSON API with routes, middleware and error handling.
- **Hello**: A single Worker that answers every request. For starting from nothing.

## Agents that build agents.

Durable Objects is the ideal infrastructure to build reliable, long lasting agents.

| Time | Agent | What woke it | What it did |
| --- | --- | --- | --- |
| 08:58 | Slack agent | “@agent the export button is broken” in #support | Opened SUP-142 in Jira |
| 08:58 | Slack agent | Same thread | Added the bug to the export runbook in Notion |
| 08:59 | Slack agent | Same thread | Replied with the ticket link |
| 09:00 | BI agent | Schedule: Mondays at 9:00 | Ran the week’s pipeline queries |
| 09:01 | BI agent | Same run | Updated the charts on acme-pipeline.judt.dev |
| 09:01 | BI agent | Same run | Posted the summary in #sales |
| 09:14 | Code review agent | Pull request #812 opened on GitHub | Read the diff, 214 lines |
| 09:15 | Code review agent | Same pull request | Left three comments on the lines |
| 09:20 | GTM agent | Northwind moved to Demo in the CRM | Built a showcase App from SaaS Starter |
| 09:22 | GTM agent | Same deal | Published northwind-demo.judt.dev |
| 09:22 | GTM agent | Same deal | Emailed the link to the rep |
| 10:03 | Code review agent | New push to #812 | Resolved two of its comments |

Each one is an App like any other, with its own code, database, Secrets and address. Your agent builds it with the same API.

## Put your agent’s first App live.

[Start free](https://staging.judt.ai/signup)