farled /ˈfɑːrˌleːd/ — Swedish. A navigable channel; a marked, safe route through water.

Your agents ship in parallel.
Give the traffic a chart.

Farled watches humans and coding agents working across branches, worktrees and repos — flags collisions before they become merge conflicts, turns production signals into safe agent tasks, and remembers what actually shipped.

Run the 60-second demo Open source & Cloud

Advisory only — Farled never locks a file or blocks a write.

Two sessions, one file, lines 10–13. Farled saw it before the pull request did.

NOTE A — WHY NOW

Agents made parallel work cheap.
Shared awareness didn’t keep up.

Invisible traffic

Five sessions across worktrees and machines, and nobody — human or agent — can answer “who else is touching this file?”

Late collisions

Overlapping edits surface at review time as merge conflicts and duplicate PRs, after the work is already paid for.

Unrouted signals

Sentry issues and CI failures queue up for human triage while capable agents sit idle — because routing them isn’t safe.

NOTE B — HOW IT WORKS

Underway — work already in motion

Local reporters and a GitHub connector observe real state: branches, worktrees, dirty files, changed line ranges, symbols, PRs. Deterministic detectors compare it all, live.

Hunk overlap — two sessions editing the same lines, flagged in seconds.
Symbol overlap — same Go function touched in different lines? Still flagged, by name.
File overlap — a local edit vs. a branch someone already pushed.
PR annotations — one living comment per pull request: current collisions, then the all-clear.

Inbound — signals becoming safe tasks

Production errors, webhooks and tickets are normalized, deduplicated and mapped to the code they implicate — then routed to agents only under rules you wrote.

Sentry intake — verified webhooks; five repeat alerts become one signal with a count.
Stack-frame mapping — frames matched to the repos and paths your team actually touches.
Dispatch with brakes — capability matching, rate limits, protected paths, named human approval for risky work.
Outcome memory — every task traced signal → agent → PR → merged or wasted.

NOTE C — SEE IT RUN

One binary. No services.
Sixty seconds to a caught collision.

The demo builds a throwaway repo with two worktrees, edits overlapping lines as a “human” and an “agent”, and shows you the signal — end to end, on your machine.

Agents query the same radar over MCP before they edit: farled_query_active_work answers with sessions, line ranges, open signals, and plain advice.

farled demo collision

▸ created throwaway repo …/app
▸ added worktree …/app-agent on branch agent/fix
▸ human edited checkout.go lines 10-12
▸ agent edited checkout.go lines 11-13
▸ both sessions reported (metadata only)

⚠ COLLISION DETECTED
  Two active sessions edit overlapping lines of
  checkout.go: agent-7 on agent/fix (lines 11-13)
  and Alice on main (lines 10-12).

🤖 agent query:
  2 active session(s) touch checkout.go;
  1 open signal, severity medium. Consider
  coordinating before editing the same lines.

✓ demo complete — the loop works end to end

NOTE D — OPEN CORE

Open source the edge. Charter the deep water.

Everything that touches your code and your laptops is Apache-2.0 and inspectable. The hosted, multi-team memory is the business.

Open source · Apache-2.0

Farled OSS

Local reporter — metadata-only, with a --preview mode that shows every byte before it’s sent
Community server: live radar, three collision detectors, dashboard — localhost, SQLite, single team
Sentry + GitHub connectors with signature verification
Agent MCP server: query, register, accept, report — 7 tools
Manual dispatch: worker registry, assignments, full lifecycle
Open protocol: 16 versioned schemas any tool can implement

go install & run the demo →

Farled Cloud · design-partner stage

Farled Cloud

Multi-team tenancy — org-scoped everything, hashed tokens; the same open protocol, so OSS reporters just work
Pull-request annotations that update in place and end in an all-clear
Agent recommendation with reasons — capability, load, access; deterministic, never a dice roll
Approval gates: high-risk work requires a named human, recorded
Policy autopilot with brakes: rate limits, protected paths, and policies that pause themselves after failures
Insights: agent success rates, policy effectiveness, task funnel

Become a design partner →

CAUTION — READ BEFORE INSTALLING ANYTHING ON ENGINEERS’ MACHINES

Metadata only. Structurally.

What Farled sends

paths · line ranges · branch names · symbol names · timestamps · counts

What it cannot send

File contents, diffs, prompts, chat logs, commit messages, secrets. No field in the wire protocol can carry them — verified by tests that plant a canary secret and audit every transmitted byte.

Built-in exclusions for .env, keys and secret paths cannot be disabled. Run farled report --preview to see exactly what would leave the machine — nothing is sent.

NOTE E — GETTING STARTED

Chart your first passage

Three routes, depending on how many of you are sailing. Every path starts the same way:

go install github.com/getfarled/farled/cmd/farled@latest

Solo · 60 seconds

Just you (and your agents)

Everything runs on your machine. Prove the loop, then run it for real.

farled demo collision
farled serve          # radar + dashboard on localhost
farled report         # in each repo / worktree

Team · self-hosted OSS

A few of you, your own server

One machine hosts the radar; everyone joins it in one command.

# host
farled serve --addr <private-ip>:4711

# every laptop (humans and agents alike)
farled quickconnect http://<private-ip>:4711

Know the trade: the community server has no authentication by design — its trust boundary is a single trusted network. Only expose it on a private network you control (a VPN/tailnet between your laptops is ideal, office Wi-Fi is not). It sees only metadata either way — but anyone who can reach it can read and write your radar. Need accounts, tokens and isolation? That's Cloud, below.

Team · Farled Cloud

Authenticated, org-isolated, annotated

An admin creates the org and hands out tokens; laptops join the same way.

Same open protocol, same reporter — plus PR annotations, agent recommendation, approval gates and policy autopilot.

# admin, once
farled-cloud org create acme "Acme"
farled-cloud token issue acme "henrik-laptop"

# every laptop
farled quickconnect https://farled.acme.dev --token fld_…

Then give any agent the chart

Farled speaks MCP, the open standard — so this works with Claude Code, Codex, Cursor, Gemini CLI, or anything else that speaks MCP. quickconnect prints your exact snippet; the universal form is:

{ "mcpServers": { "farled": { "command": "farled", "args": ["mcp"] } } }

Agents get farled_query_active_work — "who else is touching this file?" — plus the worker tools to receive, accept and report dispatched tasks.

Repositories open at launch — ask for early access or a design-partner seat. Questions? [email protected]