Getting Started

Your current tools track what humans are doing. But AI is now writing code, generating tests, and making architectural suggestions, with no visibility, no governance, and no quality gates.

The blind spot in every team using AI

Who approved the AI-generated code?
No record
Were the AI's tests reviewed before merge?
No enforcement
What did the team learn from AI-assisted work?
No capture
What will this AI-proposed change cost in infra?
Open a spreadsheet

What Elixium does differently

Elixium is the first project management platform built for human+AI teams. Every story on your board is a governed execution boundary where AI agents can operate, but only within structured, testable, and auditable limits.

01

AI proposes, humans decide. AI agents read and write to your board via MCP. They create stories, propose tests, estimate costs, and submit code. But only humans can accept work, approve tests, and ship to production.

02

Every story is a hypothesis. Work produces outcomes, not just deliverables. The Learning Loop captures what the team expected, what happened, and what to do next.

03

Platform work is product work. Infrastructure decisions and platform capabilities show up on the same board as features. ADRs with cost/benefit analysis make platform work visible and defensible to leadership.

Jira to Elixium translation

What you knowElixium
EpicEpic
SprintCurrent Iteration
BacklogBacklog lane
Story / TaskStory
Story PointsPoints
Sprint ReviewLearning capture
Definition of ReadyDoR
Definition of DoneDoD

Your first 10 minutes

Pick your role. Each path shows what you'll do first and why it matters.

What you'll notice first: Your AI coding assistant can see the board.

Open your board. Stories in the Current lane are your active iteration. Pick one or get assigned one.
Start a story. Click “Start” (or your AI agent calls start_story). This sets the story to “started” and begins the test-first cycle.
Write tests first. With TDD enabled, your AI agent proposes a test plan. You review and approve it. The tests should fail; that's the point.
Implement. Write code (with AI help) to make the tests pass. The build gate catches TypeScript, lint, and SSR issues before push.
Submit for review. Your AI agent calls submit_for_review. The story moves to “finished”, ready for human review with a linked PR.
A human accepts or rejects. Only humans move stories to Done. This is the governance boundary.
Capture what you learned. Record the outcome. “We thought X, but Y happened.” Takes 30 seconds, compounds over months.
The TDD cyclestart_story → propose_test_plan → [human approves] → implement → submit_for_review → [human accepts] → record_learning

Connect your AI agent

Elixium works with any MCP-compatible AI tool. Setup takes under 5 minutes.

~/.claude.json
{
  "mcpServers": {
    "elixium": {
      "command": "npx",
      "args": ["@elixium.ai/mcp-server"],
      "env": {
        "ELIXIUM_API_KEY": "your-api-key",
        "ELIXIUM_API_URL": "https://your-workspace.elixium.ai",
        "ELIXIUM_BOARD_SLUG": "main"
      }
    }
  }
}
API key
Open the Elixium app, click your profile (top right) to open the Profile tab, find the card for the workspace you want a key for, and click Generate Key. Copy the key immediately; it's only shown once. Detailed steps in the IDE Setup guide.

Deployment options

All three modes run the same codebase. If it works offline, it works everywhere.

What to do next

Create your first epic. With a real hypothesis. Not “Q2 Goals”; try “We believe that [specific capability] will [measurable outcome].”
Write one story with Given/When/Then. Connect your AI agent and watch it read the criteria when starting work.
Record your first team decision. Something your team decided recently that isn't written down anywhere. Now it's searchable.
Enable TDD workflow. Run one story through the full cycle: start → test plan → approve → implement → review → accept → learn.

At the end of the week, ask: What did the team learn? If you can answer that from your board, Elixium is working.