Collaborative code coordination

Two developers. One shared codebase. No surprise collisions.

CFLS gives every teammate a live signal before they touch the same work. Local Agents coordinate through one Host while your source code stays in your normal Git workflow.

See the workflow Set up a team

Code stays in Git
Per-device identity
Shared risk signal

Alice's laptop

Bob's laptop

VS Code A Alice

payments.ts

CFLS: editing payments.tsAlice

HOST

signed metadata

Kiro B Bob

payments.ts

CFLS: 1 file in playCoordinate

Git remains the source of truthCFLS coordinates work; Git moves code.

</>

Metadata, not source uploadsCoordination travels to the Host.

One identity per deviceInvitation-based team membership.

One shared coordination viewA Host keeps the team in sync.

The problem

Merge conflicts are discovered too late.

The expensive moment is not the merge itself. It is the hour two people spend implementing overlapping ideas without knowing the other person is already there.

Without coordinationblind overlap

src/payments.ts 2 active editors

09:14Alice changes refund logic.
09:18Bob changes the same path.
10:02Git discovers the collision at merge time.

- return gateway.reverse(order) + return gateway.reverse(order, reason) + return gateway.refund(order)

With CFLSshared signal

src/payments.ts Alice active

09:14Alice's local Agent shares activity metadata.
09:14Bob sees that the file is already in play.
09:15Bob coordinates or starts on a safe next task.

One deliberate decision.No surprise collision waiting at the end of the day.

How it works

A quiet coordination layer around the tools your team already uses.

Each person keeps their own editor and Git checkout. The local Agent turns activity into a shared signal; the Host distributes that signal to the rest of the team.

Alice's laptop

VS Code / KiroEditor events

down

Local CFLS AgentWatches, signs, caches

signed coordination metadata

CFLSCoordination Hostshared state

Bob's laptop

VS Code / KiroVisible context

down

Local CFLS AgentReceives state

Git

Source code stays in your existing repository and workflow.

Observe

Your local Agent sees editor activity inside the repository you authorize.

Signal

It sends a signed coordination event to the shared Host, not a copy of your source file.

Decide

Teammates get context before they begin overlapping work.

Ship

Git still handles commits, branches, reviews, and the source bytes themselves.

Interactive walkthrough

Watch two editor windows make a safer choice.

This is a product-flow illustration of the local playground. It shows the story a real 60-second recording should tell: activity becomes context before the second person edits.

Scenario: shared refund logic

Both teammates are online and looking at the same repository.

VS Code - billing-serviceA

EXPLORERsrcpayments.tsorders.tstax.ts

payments.ts

18export function refund(id) {

19return gateway.reverse(id)

20}

CFLS: OnlineAlice editing

Alice's laptop

CFLS HOST

coordination state

Kiro - billing-serviceB

EXPLORERsrcpayments.tsorders.tstax.ts

payments.ts

18export function refund(id) {

19return gateway.reverse(id)Alice is active here

20}

...Switching to tax.ts instead

CFLS: OnlineNo files in play

Bob's laptop

Product focus

Make the next edit an informed decision.

CFLS is intentionally small: it does not replace your editor, your Git host, or your team. It gives all three a shared coordination signal.

Available in the MVP

See active work

Local Agents share presence and soft-lock coordination so teammates can see when a tracked file is in play.

Available in the MVP

Connect a small team

One Host, local Agents, invitation-based device identities, and a VS Code/Kiro extension for the shared picture.

Available in the MVP

Keep source in Git

CFLS is designed to coordinate metadata. Commits, branches, reviews, and source bytes remain in your normal Git workflow.

Available in the MVP

The coordination view reaches editors and coding agents.

Local dependency analysis, active-team status, and an authenticated MCP bridge complement the live editor signals. Protected-path enforcement remains cooperative.

01
Dependency-aware impactAnalyze relationships locally and surface indirect risk context for the active team.
02
MCP transportGive coding agents team status, risk, intentions, locks, and live updates through a local connection.
03
Protected-path policyUse soft signals and cooperative hard-mode warnings for critical paths.

Install and try it

Choose the route that matches your role.

Start with the local playground for a visual demo, or install a client that joins the hosted CFLS relay with a device invitation.

Fastest visual demo

Run a Host plus Alice, Bob, and Carol on one machine.

Use this before filming your demo. It launches the local coordination scenario and lets you open separate editor windows to show the team flow.

pnpm install

pnpm playground

What you will see: a local Host and three simulated teammate environments. Open the generated workspaces in separate VS Code windows for the clearest recording.

Hosted relay

Use the live CFLS relay—no LAN or VPN setup.

The demo relay is already available at wss://sync.cfls.cyberkunju.com with a trusted TLS certificate. Each device still needs a signed invitation from the team admin before it may connect.

cfls id

cfls join --team cyberkunju-cfls --name alice

cfls connect <invitation>

Invitation required: send the public key from cfls id to the team admin. The hosted relay address is the default for cfls join, so no separate network address needs to be typed.

Windows and Linux client

Install the client, redeem its invitation, and start the local Agent automatically.

First use the downloaded client to run id and send its public key to the team admin. The invitation is device-specific; the installer then configures the hosted relay and installs the background service for this repository.

Invoke-WebRequest
                    https://cfls.cyberkunju.com/downloads/cfls.exe -OutFile
                    .\cfls.exe

.\cfls.exe id

Invoke-WebRequest
                    https://cfls.cyberkunju.com/downloads/install-windows.ps1
                    -OutFile .\install-windows.ps1

powershell -ExecutionPolicy Bypass -File
                    .\install-windows.ps1 -Workspace C:\work\repo -Name alice
                    -Invite '<invitation>'

curl -fLO
                    https://cfls.cyberkunju.com/downloads/cfls-linux-x64
                    && curl -fLO
                    https://cfls.cyberkunju.com/downloads/install-linux.sh

chmod +x cfls-linux-x64 install-linux.sh &&
                    ./cfls-linux-x64 id

./install-linux.sh --workspace /path/to/repo --name alice
                    --invite '<invitation>'

The hosted relay uses trusted TLS; do not add --insecure-tls. The published demo client is Linux x64; build the native ARM64 target from source when needed.

Supported editor extension

Install the packaged extension, then open the repository while the local Agent is running.

The extension auto-discovers the Agent through a local, per-session configuration file. VS Code and Kiro are the supported editor paths today.

code --install-extension ./cfls-coordination.vsix
                    --force

kiro --install-extension ./cfls-coordination.vsix
                    --force

Download cfls-coordination.vsix first. The clickable CFLS status item opens the active-team view; its local diff preview never sends source patches to teammates. Hosted coding agents can use the read-only MCP endpoint at https://sync.cfls.cyberkunju.com/mcp with a bearer token issued by the team admin.

Source build

Build the monorepo and package the Windows or Linux CLI.

This is the route for contributors or teams that want to make their own internal build. It requires Node.js and pnpm.

pnpm install

pnpm -r build

pnpm -C apps/cli package:win

pnpm -C apps/cli package:linux

pnpm -C apps/vscode-extension package:vsix

Published demo builds are available below. Build locally only when you need a custom internal distribution.

Download Windows client arrow Download Windows installer arrow Download Linux x64 client arrow Download Linux installer arrow Download editor extension arrow Release and packaging guide arrow Full onboarding guide arrow View source on GitHub arrow

Clear by design

Coordination without inventing another source of truth.

CFLS should make parallel work calmer, not add another place to wonder where code lives.

Does CFLS replace Git?+

No. Git remains responsible for source code, commits, branches, reviews, and remote hosting. CFLS adds real-time coordination context around that workflow.

Does CFLS upload my source code?+

The architecture is designed to analyze dependencies locally and share coordination metadata. Your source files continue to move through Git, not the coordination Host.

Can the Host run on one teammate's laptop?+

Yes, for a local demo or a small co-located session. For an always-on team setup, move the same Host configuration to a stable machine or VPS with proper TLS and backups.

What is ready now and what is next?+

The MVP includes Host/Agent coordination, editor activity, device invitations, dependency-aware risk, the active-team panel, and a local MCP bridge. Stronger protected-path enforcement and broader integrations remain product hardening.

Start with one shared signal

Let your team see the next collision before it becomes a merge conflict.

Try the playground Read the code