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

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 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.

# 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
• Self-hosting guide
• Official images

Implementation Details

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