How to build an AI-native task manager with DeepSpace

The finished app is a real-time team task manager. Every change syncs live to every teammate, and an embedded AI assistant works the board on your behalf.

• Kanban and list views over a shared tasks collection — drag a card and teammates see it move.
• Team workspaces: each team's tasks, projects, and tags live in the team's own room, invisible to other teams.
• An AI chat panel that creates, updates, completes, and organizes tasks through tool calls — under the caller's own permissions.
• Sign-in with Google, GitHub, or email and password, one-command deploys, and a live URL at <name>.app.space.

One command scaffolds the whole app — worker, schemas, pages, auth, and deploy config. npm create deepspace@latest my-tasks generates a project where the frontend and the Cloudflare Worker backend ship as a single package.

Before writing custom code, list what already exists: npx deepspace add --list shows drop-in features, including kanban (a drag-and-drop board component) and ai-chat (the chat panel, schemas, and streaming backend used in this guide). npx deepspace dev then runs the app locally with hot reload.

Task Space declares its data as typed collections with role-based access control (RBAC) rules in the schema itself. A task is a row with columns like Title, Priority, DueDate, KanbanStatus, and Order — the last two are all a kanban board needs.

// src/schemas/tasks-schema.ts (abridged from Task Space)
import type { CollectionSchema } from 'deepspace/worker'

export const tasksSchema: CollectionSchema = {
  name: 'tasks',
  columns: [
    { name: 'TeamId',       storage: 'text',   interpretation: 'plain' },
    { name: 'Title',        storage: 'text',   interpretation: 'plain' },
    { name: 'Priority',     storage: 'text',   interpretation: 'plain' },
    { name: 'DueDate',      storage: 'text',   interpretation: 'plain' },
    { name: 'KanbanStatus', storage: 'text',   interpretation: 'plain' },
    { name: 'Order',        storage: 'number', interpretation: 'plain' },
    { name: 'TagIds',       storage: 'text',   interpretation: 'json' },
  ],
  teamField: 'TeamId',
  permissions: {
    viewer: { read: false,  create: false, update: false,  delete: false },
    member: { read: 'team', create: true,  update: 'team', delete: 'team' },
    admin:  { read: true,   create: true,  update: true,   delete: true },
  },
}

The teamField line is what makes this multi-tenant. Task Space keeps shared discovery data (teams, memberships, AI chats) in the app-wide room and puts each team's tasks in a team:<id> room. The read: 'team' permission means the server only returns rows whose TeamId matches a team the caller belongs to — enforced in the Durable Object, not in client code.

The board is plain React over two hooks: useQuery subscribes to the tasks collection and re-renders on every remote change, and useMutations writes changes back. There is no cache layer, no invalidation logic, and no polling to write.

// Live board data — useQuery re-renders on every remote change
import { useQuery, useMutations } from 'deepspace'

const { records: taskRecords } = useQuery<TaskRecord>('tasks', {
  where: { TeamId: teamId },
})
const { put } = useMutations<TaskRecord>('tasks')

// Dropping a card on a column is just a merge-write:
put(task.id, { KanbanStatus: 'in_progress', Order: nextOrder })

Task Space renders five columns (Backlog, Ready, In Progress, Review, Done) from KanbanStatus and implements drag-and-drop with native HTML5 events — dropping a card is a single put that merges the new status and order. The server broadcasts the changed record to every connected teammate who is allowed to read it, so boards stay consistent without any sync code. A prebuilt board is also available via npx deepspace add kanban; Task Space instead builds its own five-column board directly on useQuery and useMutations.

The AI assistant is an AI chat panel whose tools are the app's own data operations. Task Space embeds the ChatPanel component installed by npx deepspace add ai-chat (customized locally), and its worker registers streaming chat routes built on the Vercel AI SDK — chat history persists in ai-chats and ai-messages collections with read: 'own' RBAC, so users only ever see their own conversations.

Model calls route through DeepSpace's AI proxy, so the app ships with no API keys. Task Space exposes a model picker across Anthropic (Claude), OpenAI (GPT), and Cerebras models, with streaming responses and automatic conversation compaction when history grows long.

// src/ai/tools.ts (abridged) — the assistant's hands
import { BUILT_IN_TOOLS } from 'deepspace/worker'

// Task Space exposes a subset of the SDK's built-in data tools:
const ALLOWED_TOOL_NAMES = [
  'schema.list', 'schema.describe',
  'records.query', 'records.get',
  'records.create', 'records.update', 'records.delete',
  'user.current',
]
// Tool calls execute as the calling user — per-collection RBAC
// at the Durable Object layer is the actual security boundary.

The tool list is the interesting part: the assistant gets records.query, records.create, records.update, and records.delete over the same collections the UI uses. Ask it to "move everything urgent to In Progress and set it due Friday" and it queries the board, applies the writes, and every teammate's board updates live — because the writes flow through the same Durable Object room as any human edit. Tool calls execute as the calling user, so the assistant can never read or change anything its user could not.

DeepSpace is designed so a coding agent can build this app end to end: the scaffold installs an agent skill, the CLI is scriptable with --json output, and features install with one command. Copy the prompt below into Claude Code, Cursor, or any coding agent to build your own version.

Build a team task manager on DeepSpace (docs at https://docs.deep.space).

Setup: run `npx deepspace whoami` to check login, then `npm create deepspace@latest my-tasks`. The scaffold installs the DeepSpace agent skill — read it before writing code. Run `npx deepspace add --list` and use existing features instead of hand-building: add `ai-chat` for the assistant panel and `kanban` for the board component.

Data model: collections in src/schemas/ — tasks (Title, Notes, Completed, Priority, DueDate, ProjectId, KanbanStatus, Order, TagIds), projects, and tags, plus teams and team_members. Scope workspace data per team with teamField and 'team' permissions so members only read their own team's rows.

UI: a kanban board (columns from KanbanStatus, drag-and-drop writes KanbanStatus + Order via useMutations) and a list view, both fed by useQuery so teammates see every change live.

AI assistant: embed ChatPanel and register the ai-chat routes in worker.ts. Give the model the records.* tools so it can create, update, and complete tasks — tool calls run under the calling user's permissions, so RBAC still applies.

Verify with `npx deepspace test`, then `npx deepspace deploy`.

The agent scaffolds the project, declares the schemas, wires the board and the assistant, tests with npx deepspace test, and deploys to a live .app.space URL — the same flow Task Space itself went through.

The DeepSpace documentation covers the full API surface behind this guide: collection schemas and permissions, the data hooks, AI chat, and deployment. The complete Task Space source is on GitHub, and the comparison pages cover how this stack relates to Supabase, Firebase, and Convex.