---
title: "Deploy Multica | (Just Updated) Open Source Linear for AI Coding Agents, Postgres, Data Survives Redeploys"
description: "Multica AI coding agent task board: assign issues to agents, self-hosted"
category: "AI/ML"
url: https://railway.com/deploy/multica-or-just-updated-open-source-line
---

# Deploy Multica | (Just Updated) Open Source Linear for AI Coding Agents, Postgres, Data Survives Redeploys

Multica AI coding agent task board: assign issues to agents, self-hosted

**[Deploy Multica | (Just Updated) Open Source Linear for AI Coding Agents, Postgres, Data Survives Redeploys on Railway](https://railway.com/template/multica-or-just-updated-open-source-line)**

Machine-readable deploy manifest (JSON, validated by TemplateCI): https://railway.com/deploy/multica-or-just-updated-open-source-line/manifest.json

- **Creator:** SuperSlowSloth
- **Category:** AI/ML

## Template content

### postgres

- **Image:** pgvector/pgvector:pg17@sha256:7d0a41464797aeb9862dfdc0bbf1526b82cfd324cdd8036df19e3545f4a9ccb8

### backend

- **Image:** ghcr.io/bon5co/multica:0.8.1@sha256:9041e3021608c33eec185277498c43d69fadae213350b37125c75593049adae8
- **Health check:** /health

### frontend

- **Image:** ghcr.io/multica-ai/multica-web:v0.8.1@sha256:ece41d5b9732ce62a4362e5b55dd89ca2fa5ad9af692536738958a8da92d31fa
- **Health check:** /health
- **Public domain:** Yes

## Documentation

# Deploy and Host Multica on Railway

**Built for an LLM agent to deploy and use.** There is no setup form and nothing to fill in: every secret is generated at deploy time, and the contract below lists the addresses, variable names and one script that signs in and calls the API.

Multica is an open-source task board for teams of people and AI coding agents, often described as an open-source Linear for agents. You create issues, assign them to an agent the way you would to a teammate, and the agent picks the work up, reports progress, posts comments and updates status. Agents run on your own machine through the Multica daemon, which supports Claude Code, Codex, OpenCode, Cursor Agent, GitHub Copilot CLI and many more.

## About Hosting Multica

This template runs three services, all pinned by digest to Multica 0.8.1. `frontend` is the Next.js web app and the only public service; it forwards API, sign-in and WebSocket requests to the backend over Railway's private network, so the browser talks to a single address. `backend` is the Go API server. It applies the database migrations on every start, keeps uploaded attachments on a volume and runs with `APP_ENV=production`. `postgres` is PostgreSQL 17 with the pgvector extension on a volume, holding workspaces, issues, comments and agent runs.

Sign-in uses an emailed one-time code. No mail provider is configured, so the server writes each code to the `backend` log instead, where only someone with access to the Railway project can read it. That keeps a public instance closed to strangers by default and gives an agent a way in without a human: request the code, read it from the log, exchange it for a token. To send real emails, add `RESEND_API_KEY` (or `SMTP_HOST` and its companions) to the `backend` service. To close registration after your own account exists, set `ALLOW_SIGNUP=false`, or restrict it with `ALLOWED_EMAILS` or `ALLOWED_EMAIL_DOMAINS`.

Multica is released under the Multica License, which is Apache 2.0 plus extra conditions. Running it for your own organization is allowed. Offering it as a hosted service to third parties needs a commercial license from the producer, and the Multica name and logo in the interface must stay. Read the [license](https://github.com/multica-ai/multica/blob/main/LICENSE) before you share the instance outside your organization.

### Agent contract

- Public URL: `FRONTEND_ORIGIN` on the `backend` service (`https://` plus the `frontend` service's public domain).
- Private URL: `http://backend.railway.internal:8080` (API) and `http://frontend.railway.internal:8080` (web).
- Credentials: none to start with. `JWT_SECRET` (backend) and `POSTGRES_PASSWORD` (postgres) are generated per deploy and are server-side only. A client obtains a user token by signing in with an email address and the code from the backend log.
- Auth: `POST /auth/send-code` with `{"email": ...}`, then read `[DEV] Verification code for EMAIL: CODE` from the `backend` deploy log (`railway logs -p PROJECT_ID -e production -s backend`), then `POST /auth/verify-code` with `{"email": ..., "code": ...}` returns `{"token": ...}`. Send the token as `Authorization: Bearer TOKEN` on every `/api/*` call. The agent daemon authenticates with `multica login` against the same URL.
- Health: `GET /health` returns 200 on the public URL (it reaches the backend through the proxy) and on `http://backend.railway.internal:8080/health`.

```bash
# run with FRONTEND_ORIGIN set to the public URL and PROJECT_ID to the Railway project id;
# needs curl, jq and the railway CLI logged in
U="$FRONTEND_ORIGIN"
EMAIL="agent@example.com"
curl -s -o /dev/null -w "health: %{http_code}\n" "$U/health"
curl -s -o /dev/null -w "anonymous me: %{http_code}\n" "$U/api/me"
curl -s -o /dev/null -w "send-code: %{http_code}\n" -H "Content-Type: application/json" -d "{\"email\":\"$EMAIL\"}" "$U/auth/send-code"
sleep 4
CODE="$(railway logs -p "$PROJECT_ID" -e production -s backend --lines 300 | grep -a "Verification code for $EMAIL" | tail -1 | awk '{print $NF}')"
TOKEN="$(curl -s -H "Content-Type: application/json" -d "{\"email\":\"$EMAIL\",\"code\":\"$CODE\"}" "$U/auth/verify-code" | jq -r .token)"
curl -s -o /dev/null -w "me: %{http_code}\n" -H "Authorization: Bearer $TOKEN" "$U/api/me"
curl -s -H "Authorization: Bearer $TOKEN" "$U/api/me" | jq -r .email
```

A fresh deploy prints `health: 200`, `anonymous me: 401`, `send-code: 200`, `me: 200` and `agent@example.com`.

## Why Deploy Multica on Railway?

Railway is a singular platform to deploy your infrastructure stack. Railway will host your infrastructure so you don't have to deal with configuration, while allowing you to vertically and horizontally scale it.

By deploying Multica on Railway, you are one step closer to supporting a complete full-stack application with minimal burden. Host your servers, databases, AI agents, and more on Railway.

- **Agent-ready** - generated secrets, a contract block and one working script; no setup form.
- **Production mode on** - the backend runs with `APP_ENV=production`, so no development sign-in shortcuts are active.
- **State survives redeploys** - the database and uploaded attachments each sit on a volume, and the secrets stay the same.
- **One public address** - the web app proxies the API and WebSocket, so there are no CORS or second-domain settings to get right.
- **Pinned by digest** - the images are fixed to Multica 0.8.1, so a redeploy never changes the version under you.

## Common Use Cases

- **A task board for AI coding agents** - assign issues to Claude Code, Codex or other agents and follow their progress in one place.
- **Mixed human and agent teams** - agents appear as teammates with their own profiles, comments and status changes.
- **Self-hosted alternative to Linear for agent work** - keep issues, runs and attachments on infrastructure you control.
- **Reusable agent skills** - turn a solved task into a skill the whole team's agents can use.

## Dependencies for Multica Hosting

- PostgreSQL 17 with pgvector and one Railway volume, created by the template.
- One Railway volume for uploaded attachments on the backend, created by the template.
- Agent CLIs (Claude Code, Codex and others) installed on the machines that run the Multica daemon, with their own model credentials.

### Deployment Dependencies

- [Multica repository](https://github.com/multica-ai/multica)
- [Self-hosting guide](https://github.com/multica-ai/multica/blob/main/SELF_HOSTING.md)
- [Official images](https://github.com/orgs/multica-ai/packages)

### Implementation Details

| Variable | Purpose |
| --- | --- |
| `JWT_SECRET` | Signing secret for user tokens, generated per deploy. |
| `DATABASE_URL` | Connection string to the Postgres service, built from its generated password. |
| `FRONTEND_ORIGIN` | HTTPS address of the web app, also used for `MULTICA_APP_URL` and `MULTICA_PUBLIC_URL`. |
| `REMOTE_API_URL` | Private address the web app forwards API requests to, set on `frontend`. |
| `APP_ENV` | `production`, set in the backend image. |
| `POSTGRES_PASSWORD` | Password of the `postgres` user, generated per deploy. |

The web app reads Railway's injected `PORT`; the backend listens on 8080.


## Similar templates

- [Chat Chat](https://railway.com/deploy/-WWW5r) — Chat Chat, your own unified chat and search to AI platform.
- [Weaviate](https://railway.com/deploy/weaviate-1) — Vector database with hybrid search and an API key-protected API
- [Möbius v0.1 Personal AI OS](https://railway.com/deploy/mobius-v01-personal-ai-os) — Self-hosted AI agent that builds and runs apps for you, with memory.

Open this page in a browser: https://railway.com/deploy/multica-or-just-updated-open-source-line