NewFairlx+ opens PRs from your board

Track the work. Ship the fix.
Pay for what you use.

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

SecureIsolatedCloud Sandboxes
Accept-Gated Agent RunsScrum · Kanban · Hybrid BoardsSeat + Included CreditsIsolated Cloud Sandboxes
Fairlx Agile Work OS Dashboard Preview

Works with the tools your team already ships in

  • GitHub
  • Slack
  • Discord
  • Teams
  • WhatsApp
  • Azure
  • 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
  • Scrum · Kanban · Hybrid
  • Roles at every level
02

Ticket in. Pull request out.

Assign a work item to @Fairlx. It reads the ticket, posts a plan you Accept, boots an isolated Azure sandbox, and opens the PR under your GitHub identity — not a chatbot in a sidebar.

  • Accept-gated writes
  • Isolated Azure sandbox
  • PR under your identity
03

One runtime, every surface

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

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

Ticket to merge, measured

Fairlx+ cuts a branch, runs the sandbox, and opens the PR under your identity. 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

Kanban, Scrum or Hybrid per project. WIP limits with visible warnings, swimlanes by epic or assignee, and cards that show exactly the fields you choose.

  • Kanban, Scrum or Hybrid modes per project
  • WIP limits with visible warning indicators
  • Swimlanes by epic, priority, or assignee
  • Cards that display only the fields you configure
Boards UI preview
Fair Bot

Meet
Fair Bot

AI teammates you can give real work to. Bots can sign in to your tools, use them just like you do, 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 Azure sandbox

Assign a work item to @Fairlx. It reads the ticket context, comments, and repository files, then posts a clear implementation plan. Once you click Accept, it provisions an isolated Azure container — git and shell never touch the Fairlx host.

  • Accept-gated write guards — nothing runs until approved
  • Dedicated Azure Container App with isolated sandbox environment
  • Auto-generates plan, identifies affected files, and tracks dependencies
  • Specialist agents: planner, builder, tester, and reviewer
From ticket to an isolated Azure sandbox
02 · Live Preview & Tests

Clickable live preview with automated test loops

The live preview mounts only after automated container health-checks return 200 OK. 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 health-check 200
  • 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 your identity, triggered from anywhere

The pull request opens directly from the sandbox under your verified GitHub identity — never an anonymous workspace bot. Interact with @Fairlx directly in Slack, Discord, Teams, WhatsApp, or operate it inside Cursor via MCP.

  • Opens pull request under your verified GitHub identity
  • Operate Fairlx from Cursor or Claude via Model Context Protocol (MCP)
  • @Fairlx commands in Slack, Discord, Teams, and WhatsApp
  • Auto-advances work item status across your custom workflow
PR opened under your identity, 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 Azure sandboxes

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

Assign a work item, Accept the plan, and Fairlx boots a dedicated Azure VM. Git, shell, and the agent stay inside it — one live sandbox per person per project.

Azure sandbox
Swipe to rotate · tap to inspect
  • Never on the Fairlx host

    Git, shell, and the coding agent execute only inside an isolated Azure VM. The host never sees the workspace disk.

    Azure Container Apps
  • One live box per person

    One sandbox per user per project. Ten teammates get ten VMs — you never inherit someone else’s workspace.

    User × project
  • Pause at 15 · destroy at 30

    Idle boxes suspend in memory (disk kept, CPU billed off), then auto-delete after 30 minutes so leftover storage cannot sit.

    Memory-mode suspend
  • Live only after 200 OK

    Create → clone → install → start. The preview iframe mounts only after the container health-check returns 200.

    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 diagnoses the trace, rewrites the code, and re-runs the suite until it passes.

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 loops back — refining the patch until every test is green.

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 Azure container az-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

← AST Code Generator

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

Signed commit, linked to WEB-12, preview deployed

Autonomous loop executing

Step 1 of 7·Test fails

ACTIVE

Self-Healing Test Cycles

When tests fail in the sandbox, the agent parses the stack trace, applies a refined AST patch, and re-runs the suite until 100% green. Zero human intervention for mechanical breakages.

Ephemeral Azure Sandboxes

Agents write inside ephemeral Azure Container Apps with zero host filesystem access. Production codebases stay untouched while live previews let your team test instantly.

Cryptographic Sign-off

Every pull request requires verified commit signatures and supervisor approval before main branch merges. Trigger directly via Slack, Discord, Linear, 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 Azure sandbox.

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

Chat is an operations surface

@Fairlx in Slack, Discord, Teams, or WhatsApp 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
98 tools
>"Plan sprint from backlog and start session on urgent bug"
fairlx_sprint_plan
Planned
fairlx_session_start
Active
fairlx_work_item_update
Synced
Two-way MCP runtimebidirectional · HTTP/SSE

MCP in both directions

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

GitHub PR· northwind/web
#412

fix(nav): prevent mobile viewport clipping #412

Openfairlx/WEB-12→main
ci / test
14 passed · 42s
ci / preview
healthy (200 OK)
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 your identity, 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
Automated and running 24/7 without manual supervision
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. No tiers, no gated features.

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
Custom fields
Assignee
PR Priya Raman
Labels
billingq3
Story pts
5
Due date
Sep 18, 2026
Confidence
80%
Design
figma.com/file/…
Customer
Acme Corp (EU)

16 types · space scoped

16+ custom field types

Text, number, date, select, user, currency, percentage, URL, labels — scoped to workspace, space or project, with defaults and validation.

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 GB / 5 GB

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

Docs with versions

14 document categories from PRD to release notes, version history, tags, and 5 GB 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 teams 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?

Join thousands of teams who use Fairlx to plan, track, and deliver their best work.

Free forever tier for small teams
No credit card required
Unlimited users per workspace