NewFairlx+ opens PRs from your board

AI project management software for agile teams. Track the work. Ship the fix.
AI credits included.

Fairlx is the agile work OS for modern teams — boards, sprints, workflows, docs, and analytics in one hierarchy. With Fairlx Plus, assign bugs to autonomous agents that code in isolated cloud sandboxes, boot live previews, and open pull requests.

SecureIsolatedCloud Sandboxes
Plan Approval Before CodeSprints · Backlog · Kanban BoardSeat + Included CreditsIsolated Cloud Sandboxes
Fairlx sprint board with work items, statuses and assignees

Works with the tools your team already ships in

  • GitHub
  • Slack
  • Discord
  • Cursor
  • Claude
  • OpenAI
  • Gemini
Why Fairlx

Most tools track work. A few help plan it. Fairlx is built so the work gets finished.

Three decisions shaped the product: a hierarchy that scales without plugins, an agent that takes a work item to a reviewed PR, and one runtime you can run from Slack, Cursor, or GitHub.

01

A hierarchy that scales

Organizations hold workspaces; workspaces hold spaces; spaces hold projects; projects hold work items. Roles and workflows inherit down — no plugins required.

  • Personal or Org
  • Sprints · Backlog · Board
  • Roles at every level
02

Ticket in. Pull request out.

Assign a work item to @Fairlx. It reads the ticket, posts a plan you approve, codes in an isolated cloud sandbox, and opens the PR under a real GitHub account, yours once you connect GitHub — not a chatbot in a sidebar.

  • Plan approval first
  • Isolated cloud sandbox
  • PR under a real GitHub account
03

One runtime, every surface

The same agent answers in Slack and Discord, exposes itself to Cursor via MCP, and shows up on the pull request. One session — wherever the team already works.

  • Slack · Discord
  • Cursor MCP
  • GitHub on the item
04

Ticket to merge, measured

Fairlx+ cuts a branch, runs the sandbox, and opens the PR under a real GitHub account. Click a station to pin it.

The work OS

Everything the team needs to plan, run and measure a sprint — in one place.

No marketplace plugins to assemble. Boards, backlog, timeline, workflows, docs and analytics share one data model, so a change in one shows up everywhere

Visual Agile Boards for Modern Teams

A Kanban board for each project's active sprint. Custom columns next to your workflow statuses, quick create in any column, and bulk edits.

  • A board for each project's active sprint
  • Custom columns alongside your workflow statuses
  • Sort any column by priority or due date
  • Select many cards and update them together
Boards UI preview
Fair Bot

Meet
Fair Bot

AI teammates you can give real work to. Bots use your connected tools and come back with finished work.

Product Team

Launch new dashboard

SM
SM
Surendra Mattaparthi

Hey team, let's get the new project dashboard launched this week! Can we organize the tasks and get it ready?

Happy

On it! I've organized the sprint tasks on our Kanban board:

• @Sam — Build analytics & stats widgets
• @Alex — Test layout on desktop & mobile
• @Annie — Write user guide & help tips

Moved project to In Progress on the board. @Sam, you're up first!

Sam

Finished building the new analytics cards and charts! Everything loads instantly and is fully responsive.

Moved my card to In Review on the board. @Alex ready for your check!

03 · Fairlx+

Meet the teammate that opens the pull request.

Not a chatbot in a sidebar. Fairlx+ takes a work item from your board to a reviewed PR — with a plan you approve, an isolated sandbox, and a preview you can click.

01 · Plan & Sandbox

From ticket to an isolated cloud sandbox

Assign a work item to @Fairlx. It reads the ticket context, comments, and repository files, then posts a clear implementation plan. Once you approve it, the agent codes in an isolated cloud sandbox — git and shell never touch the Fairlx host.

  • Plan approval before code — merges wait for a person by default
  • A dedicated, isolated cloud sandbox for every work item
  • Auto-generates plan, identifies affected files, and tracks dependencies
  • Specialist agents: planner, builder, tester, and reviewer
From ticket to an isolated cloud sandbox
02 · Live Preview & Tests

Clickable live preview with automated test loops

The live preview mounts only after the app's dev server answers its health check. Review code changes side-by-side, watch test suites run in real time, and let the agent auto-fix failing tests before review.

  • Live preview iframe mounts only after the app answers
  • Automated test runner loops with self-healing feedback
  • Side-by-side git diff review directly in the browser
  • Instant shareable preview URLs for team and stakeholder testing
Clickable live preview with automated test loops
03 · Verified PR & Everywhere

PR opened under a real GitHub account, triggered from anywhere

The pull request opens from the sandbox under a real teammate’s GitHub account, yours once you connect GitHub, never an anonymous workspace bot. Interact with @Fairlx directly in Slack or Discord, or operate it inside Cursor via MCP.

  • Opens the pull request under your GitHub account once you connect it
  • Operate Fairlx from Cursor or Claude via Model Context Protocol (MCP)
  • @Fairlx commands in Slack and Discord
  • Auto-advances work item status across your custom workflow
PR opened under a real GitHub account, triggered from anywhere
04 · Code reviews

Build, review,
and ship.

Streamline code reviews with clear diffs, better context, and fewer back-and-forth comments. Keep PRs moving without leaving Fairlx.

In Review3
  • FLX-96feat: enhance message editing functionality in agent chat
  • FLX-95Add workflow transition tools and role-aware routing
  • FLX-94feat: integrate Redis caching and request coalescing
In Progress4
  • FLX-93feat: implement default active sprint on project create
  • FLX-92feat: real-time diff comment threads & WebSocket sync
  • FLX-87Optimize diff syntax tree generation for large files
  • FLX-85Fix avatar alignment in nested workspace reviews
Todo4
  • FLX-91feat: automated PR review summary with Fairlx Agent
  • FLX-82Add keyboard shortcuts for PR file tree navigation
  • FLX-79Reduce unnecessary AST re-rendering on code hover
  • FLX-76Speed up CI pipelines for multi-repo workspace builds
Backlog3
  • FLX-71Support collapsible side-by-side diff hunk view
  • FLX-68Audit trail logging for branch protection overrides
  • FLX-64Custom markdown preview renderer in review comments
TSfairlx/src/features/agent/api/use-agent-runs.ts
01import { client } from "@/lib/rpc";
02import { QUERY_CONFIG } from "@/lib/query-config";
03import { rewindMessage } from "../lib/edit-message";
04import { AGENT_RUNS_QUERY_KEY } from "../constants";
05import type { AgentRun, SendMessageResponse } from "../types";
06 
07export const useSendAgentMessage = () => {
08 const queryClient = useQueryClient();
09 
10 return useMutation<SendMessageResponse, Error, { content: string }>({
11 mutationFn: async ({ content }) => {
12 const response = await client.api.agent.runs[":runId"].$post({ json: { content } });
13 if (!response.ok) throw new Error("Failed to send message.");
14 return (await response.json()) as SendMessageResponse;
15 },
16 onSuccess: (result) => {
17 queryClient.invalidateQueries({ queryKey: AGENT_RUNS_QUERY_KEY });
18 },
19 });
20};
21 
22export function shouldPollAgentRun(status?: string): boolean {
23 return status === "running" || status === "awaiting_confirmation";
24}
25 
26export function agentRunPollMs(status?: string): number | false {
27 if (status === "running") return 2000;
28 return false;
29}
01import { client } from "@/lib/rpc";
02import { QUERY_CONFIG } from "@/lib/query-config";
03import { rewindToEditedUserMessage } from "../lib/edit-user-message";
04import { AGENT_RUNS_QUERY_KEY } from "../constants";
05import type { AgentRun, SendMessageRequest, SendMessageResponse } from "../types";
06 
07export const useSendAgentMessage = () => {
08 const queryClient = useQueryClient();
09 
10 return useMutation<SendMessageResponse, Error, SendMessageRequest, { previous?: AgentRun }>({
11 mutationFn: async ({ param, json }) => {
12 const response = await client.api.agent.runs[":runId"].messages.$post({ param, json });
13 if (!response.ok) await readError(response, "Failed to send message.");
14 return (await response.json()) as SendMessageResponse;
15 },
16 onMutate: async ({ param, json }) => {
17 const replaceId = json.replaceMessageId;
18 if (!replaceId) return {};
19 const key = agentRunQueryKey(param.runId);
20 await queryClient.cancelQueries({ queryKey: key });
21 const prev = queryClient.getQueryData<AgentRun>(key);
22 const rewound = rewindToEditedUserMessage(prev?.messages ?? [], replaceId);
23 queryClient.setQueryData(key, { ...prev, ...rewound, status: "running" });
24 return { previous: prev };
25 },
26 onSuccess: (result) => {
27 queryClient.invalidateQueries({ queryKey: AGENT_RUNS_QUERY_KEY });
28 },
29 });
30};
Isolated cloud sandboxes

Code runs in a box.
Never on the Fairlx host.

Assign a work item and Fairlx boots a dedicated cloud VM. Git, shell, and the agent stay inside it — one live sandbox per work item.

  • Never on the Fairlx host

    Git, shell, and every command the agent runs execute only inside an isolated cloud VM. No model key enters the box, and the Fairlx host never runs your code.

    Isolated cloud sandbox
  • One live box per work item

    Each work item gets its own sandbox, up to 5 live at once per workspace, and every agent on it works in its own git worktree and branch — you never inherit someone else’s workspace.

    Work item × worktree
  • Pause at 15 min · delete at 24 h

    Idle boxes suspend in memory, disk kept, once the agents’ branches are pushed. Work item boxes are deleted after 24 hours idle, chat boxes after 30 minutes.

    Memory-mode suspend
  • Live once the app answers

    Create → clone → install → start. The preview iframe mounts only after the app's dev server answers on its port.

    Shareable preview URL
  • Secrets injected, never returned

    Project secrets are names-only in the UI and injected at session start. Values never come back through tools or logs.

    Redacted in every log
  • Self-heal without wiping

    Compile and test failures are patched in place. Fairlx does not reboot or destroy the VM — uncommitted work stays.

    In-sandbox repair loop
Continuous Automation

Self-healing loops.
From failing test to green PR.

Fairlx compiles triggers, sandboxes, and verification into a single continuous loop. When a test fails in the container, the agent reads the failure, edits the code, and re-runs the suite. After a set number of tries it stops and tells you what is still broken.

Autonomous Pipeline Stream

A test fails. Fairlx ships the fix.

The agent detects the failure, diagnoses the stack trace, writes a fix, and re-runs the suite. If tests still fail, it refines the patch and re-runs the suite, up to a set number of tries.

loop-worker-01
LIVE TRACE
Point 1/7
Incoming:→ GitHub Actions CI
FAIL TRACE RECEIVED

CI Webhook Triggered

Workflow run #418 · commit a91f0c

$pnpm test:unit --filter=web
FAILsrc/components/NavBar.test.tsx > responsive layout
✕renders on mobile viewport (375px): overflow-x detected (412px > 375px)
atNavBar.test.tsx:44:18 in checkHorizontalOverflow()
infoAutomated triage agent assigned ephemeral cloud sandbox sbx-491

CI webhook detected failing viewport test in NavBar.test.tsx and assigned an autonomous sandbox.

Test fails

← GitHub Actions CI

CI detects 2 failing tests in NavBar.test.tsx

Agent investigates

← Fairlx Diagnostic Engine

Reads stack trace, identifies root cause in CSS overflow

Writes a patch

← Agent Code Editor

Applies clamp() fix to sidebar width calculation

Tests still failing

← Vitest Runner

1 edge case remains — sub-400px viewport overflow

Self-healing loop route (Standby on pass)

Agent refines fix

← Self-Healing Refiner

Adds overflow-y-auto + clamps min-width on sidebar

All tests pass

← Test Verification Suite

14/14 green — zero regressions

PR opened

← GitHub Pull Request API

Commit linked to WEB-12, preview live

Autonomous loop executing

Step 1 of 7·Test fails

ACTIVE

Self-Healing Test Cycles

When tests fail in the sandbox, the agent reads the failure, edits the code, and re-runs the suite. After a set number of tries, it stops and reports what still fails.

Ephemeral Cloud Sandboxes

Agents write inside ephemeral, isolated cloud sandboxes with zero host filesystem access. Production codebases stay untouched while live previews let your team test instantly.

Approval before merge

Merges wait for a person unless the agent runs Autonomous with Auto Merge on. Start work from Slack, Discord, or MCP.

05 · Everywhere you work

Operate the board from Slack, Cursor or a pull request.

Fairlx doesn't ask your team to live in another tab. The same runtime answers in the thread, exposes itself to your IDE, and shows up on the PR.

eng-web· thread
Slack
Marcus Lee
Marcus Lee10:42 AM

@Fairlxfix WEB-12 — sidebar overflows on mobile screen

FairlxAgent10:42 AM

Resuming session for WEB-12 in its sandbox.

Sandbox healthyaca-web-12 :3000 (port answered)
Automated tests14/14 passed · 0.8s
Pull request#412 fairlx/WEB-12
Preview LiveReview PR

Chat is an operations surface

@Fairlx in Slack or Discord starts or resumes the session bound to a work item. Slash commands create bugs, stories, and tasks directly from the thread.

Cursor · MCP· fairlx-server
148 tools
>"Plan sprint from backlog and start session on urgent bug"
fairlx_sprint_plan
Planned
fairlx_coding_session_start
Active
fairlx_work_item_update
Synced
Two-way MCP runtimetwo-way · HTTP

MCP in both directions

Cursor, Claude, or Codex operate Fairlx through about 150 fairlx_* tools — plan sprints, move items, start sessions. Fairlx calls your HTTP MCP servers back: Sentry, Datadog, or your own.

GitHub PR· northwind/web
#412

fix(nav): prevent mobile viewport clipping #412

Openfairlx/WEB-12→main
ci / test
14 passed · 42s
fairlx/quality-gates
passed
fairlx / linked
WEB-12
e41c9e2clamp sidebar height
+32 -8

GitHub on the work item

Link a repo to the project. Commits, branches, and pull requests bind to the item, PRs open under a real GitHub account, and merges automatically move the item along your workflow.

Solo Founder Superpower

One person can now
build and run an entire company.

Fairlx turns you into a 10x team. Drop in your specs, assign work to people or AI, let top models code in isolated cloud sandboxes, and launch with live interactive previews.

Solo Founder
You
Understands PRDs, FRDs & Documents

Read PRDs & Specs

Drop in any document — a product spec (PRD), a feature document (FRD), or rough notes. Fairlx extracts every detail so the AI understands what needs to be built.

Connected Documents & Specs Ready to Build
Checkout & Billing PortalPRD

Product Requirements · What users need & expect

Parsed
Stripe Webhook & OAuth LogicFRD

Functional Requirements · How the system should work

Parsed
Mobile & Desktop ScreensSPEC

Figma Design Spec · Visual layout & design tokens

Synced
AI reads documents and creates step-by-step planZero Guesswork
Runs in the cloud. You approve the plan and the merge, or turn on Autonomous with Auto Merge to let it run unattended.
06 · Already in the box

Everything else a real team needs — already in the box.

Built with enterprise needs in mind while staying simple enough for a two-person studio. Boards, sprints, docs, and roles are on every plan.

Fairlx· WEB-18
In Progress
WEB-18Story

Billing usage chart on workspace home

Show traffic, storage and compute for the current month with the threshold line.

Subtasks · 2 of 450%
Aggregation query endpointMarcus Lee
Chart rendering primitivePR
Threshold line & alert copyPR
Details
Assignee
PR Priya Raman
Labels
billingq3
Story pts
5
Due date
Sep 18, 2026
Priority
High
Estimate
8h

Your types, priorities & labels

Your own types and labels

Set your own work item types, priorities and labels for each project. Story points, due dates and subtasks come built in.

Timesheet· Week of Sep 14
Export CSV
PR

Priya Raman

Web Platform

Sep 14 – 20
DateTaskHours
Sep 14Usage chart2.5h
Sep 15Usage chart2.0h
Sep 16Scope markers3.0h
Sep 17Bulk edit4.0h
Sep 18Bulk edit2.5h
Weekly summaryTotal: 14.00 hours

Time tracking

Log hours per work item, compare estimates to actuals, and export a weekly timesheet per person.

Documents· Web app
Upload
Search documents
All documents (4)1.8 MB / 10 MB

Billing v2 — Product PRD

PRD · 84 KB

MDPR

Usage aggregation engine spec

Tech Spec · 126 KB

MDMarcus Lee

Public REST & MCP work items

API Doc · 61 KB

MDAT

Release notes v2.8

Release · 240 KB

PDFSC

Project docs

14 document categories from PRD to release notes, version labels, tags, and 10 MB per project.

Permissions· Web Platform
Server-side

Work Items

View work items
Edit work items

Sprints

Start & complete sprints

Members & Teams

Manage members

Documents

Create & edit docs
Guards run on the serverDeveloper · 3 scopes

Roles at every level

Organization, workspace, space, team and project roles — plus custom roles stored in the database. Guards run server-side.

Teams· Billing & Infrastructure
Active

Web Platform

8 members · Lead Priya Raman

Board, sprints, deployments and analytics for the web app.

PRMarcus LeeAT
Manage

Payments & Ledger

5 members · Lead Sara Chen

Approvals, Stripe webhooks, and ledger integrity.

SCJK
Manage

Teams & programs

Teams with leads and granular permissions. Programs group projects for portfolio-level analytics.

Notifications
Mark all read
Inbox2In-app · Email · Webhook

Fairlx+ opened PR #412 for WEB-12

2 minutes ago

SC

Sara requested your approval on WEB-30

25 minutes ago

Marcus Lee

Marcus mentioned you in WEB-21

1 hour ago

AT

Aiko adjusted due date on WEB-24

3 hours ago

Notifications that respect you

Ten event types delivered in-app, by email or webhook — assignments, approvals, mentions, due dates, PRs.

Ready to streamline your
project management?

Plan, track, and ship your team's work in one place.

Free for personal accounts
No credit card for personal use
Teams start at one Plus license