← Amber 2.0

Spaces

2 Apr 2026 · Tristan Wright

The Problem

Agent work disappears into chat. You ask for a sprint summary, the agent gives you one, and it scrolls off screen in three messages. Next day you ask again. The Jira board is in one tab, GitHub PRs in another, your metrics dashboard somewhere else. There’s no persistent place to see the state of things without asking.

What Spaces Are

A space is a personal dashboard you build from blocks. Drop in a live number, a task board, a feed of recent activity, a chart. Arrange them how you like. They stay there — you don’t have to ask for them again.

Think of it like building your own control panel for a project. You decide what’s on it, and it updates itself.

Why It Matters

Chat is good for doing work. It’s terrible for monitoring work. When you’ve got agents running across multiple projects, you need to see state at a glance — what’s progressing, what’s stuck, what ran overnight. Without that, you’re constantly asking “what happened?” instead of just looking.

Spaces turn the platform from a conversation tool into an operational one. The agent isn’t just something you talk to — it’s something that works in the background and reports into a dashboard you control.

What You Can Put On A Space

Eight types of blocks:

  • Note — text you want visible. Meeting notes, reminders, context.
  • Shortcut — a link to a tool, URL, or project you open often.
  • Metric — a live number. Error count, build time, open tickets.
  • Feed — a rolling list of recent activity. Commits, Jira updates, messages.
  • Table — rows and columns of live data. Tickets, users, records.
  • Chart — a bar, line, or pie chart showing trends over time.
  • Kanban — a full task board with columns and drag-and-drop.
  • Generic — a catch-all for custom or experimental block types.

You drag blocks to reorder them. Each one has its own settings for what data it shows and how often it refreshes.

Connecting to Your Tools

Blocks can pull live data from services your team already uses — GitHub, Jira, and Microsoft (calendar, email, Teams). You pick a service, pick what data you want (e.g. “open PRs in this repo”), and the block keeps itself up to date.

Task Boards

The kanban block is the most complete. It’s a proper task board inside your space — columns, cards, priorities, assignees, drag-and-drop.

It can also sync with GitHub issues or Jira tickets, so cards on your board mirror real tickets. Move a card to “Done” and the external ticket updates too.

Running Things on a Schedule

Each space can have automations — things that run on a schedule and feed results back into the space. You set up what to do (ask the agent a question, run a workflow, call an API) and when to do it (every hour, every morning, once next Tuesday).

Results show up in the space’s output log, so you can see what ran and what it produced.

Templates

You can start from a blank space or from a template — a pre-built layout someone else designed. A “sprint tracker” template, a “project health” template. Use it as-is or customise it.

Technical Detail — Tile Architecture

Each tile type is a self-contained React component rendered in a responsive grid (TileGrid). Configuration is managed through TileConfigModal which handles type selection, data source binding, and display options.

Data tiles use the useTileData hook which implements polling with exponential backoff, per-tile caching, and refresh controls. Data is fetched via POST /spaces/{spaceId}/tiles/{tileId}/data.

Technical Detail — Connectors and Operations

Connectors are project-level integrations (stored in projectConnections). The ConnectorPicker reads enabled connections and filters by provider (microsoft, github, jira).

Operations are fetched from GET /spaces/providers/operations and represent specific data queries (e.g. “list open PRs”, “get sprint velocity”). The OperationPicker renders available operations with parameter inputs.

Technical Detail — Kanban External Sync

The ExternalSyncConfig component manages bidirectional sync between kanban boards and external ticket systems. Configuration includes:

  • Field mapping presets for GitHub and Jira (title, description, priority, assignee)
  • Column mapping (external status → board column)
  • Priority mapping (external levels → internal levels)
  • Sync policy (manual trigger or interval-based)

Sync runs via POST /spaces/{spaceId}/tiles/{tileId}/sync. Board items are stored in Convex (spaceBoardItems) with full CRUD and cross-column move support.

Technical Detail — Automations

Automations link scheduledTasks (from the Convex scheduledTasks table) to a space via spaceAutomations. The CreateAutomationDialog wizard supports five action types:

  • AI prompt (raw prompt sent to agent)
  • Workflow (triggers a saved workflow by ID)
  • Skill (executes a skill by name)
  • HTTP request (arbitrary URL with method/headers/body)
  • Agent team (runs a multi-agent template)

Schedule types: interval (minutes/hours/days), cron expression, or one-time timestamp. Outputs are retrieved via GET /spaces/{spaceId}/outputs.

Technical Detail — Data Model

Convex tables: spaces, spaceMembers, spaceTiles, spaceBoardItems, spaceAutomations, tileDataAuditLog.

Key Convex functions: spaces.listByUser, spaces.getById, spaces.createTile, spaces.updateTile, spaces.reorderTiles, spaces.listAutomations, spaces.linkAutomation, spaces.listBoardItems, spaces.createBoardItem, spaces.crossColumnMove.

Templates are fetched from GET /spaces/templates and applied via POST /spaces/from-template. Cover images use Convex storage with generated upload URLs.