Farled

THE FULL CHART — CONTINUED FROM THE OVERVIEW

The platform, sounding by sounding.

Live radar, passage plans, dispatch, connectors, and the open protocol — how each works, what it collects, and how to wire it up. Advisory only: Farled never locks a file or blocks a write.

NOTE F — 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 on 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 G — PASSAGE PLANS

Passage plans — deconflicted before departure

Radar tells you about collisions as they happen. Plans prevent them: at the end of its planning phase, an agent files the footprint it intends to change — path globs, one-line summary — and gets a traffic advisory back before writing any code.

  • File → advisory — farled_file_plan answers clear, sequence after (someone filed that water first), or coordinate (someone is already editing inside it).
  • Never a lock — a plan is a reservation on the chart, not a lease on the code. Anyone can still sail anywhere; they just do it informed.
  • Drift detection — observed edits are reconciled against the filed route. Leave your footprint and a plan_drift signal flags the scope creep; rejoin it and the signal clears.
  • Auto-plans at dispatch Cloud — an assigned task reserves its own footprint the moment it’s dispatched, with zero agent effort.
  • One shared discipline — the impact-surface skill teaches every agent (any vendor) to derive footprints from a PRD or plan the same way, so advisories stay comparable across the whole team.

Read the pilot book: lifecycle, advisory rules, drift, wiring agents →

NOTE H — 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, plan — ten tools in all
  • Passage plans: declare a footprint, get a traffic advisory before coding; drift detection keeps plans honest
  • Impact-surface skill: one installable discipline for how any agent derives & files footprints
  • 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
  • Harbor report: scan recent pull requests and see the collisions Farled would have caught before installing laptop reporters; open the full report or export CSV
  • 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’s approval, recorded
  • Policy autopilot with brakes: rate limits, protected paths, and policies that pause themselves after failures
  • Auto-plans at dispatch: assigned tasks reserve their footprint automatically — zero agent effort
  • Insights: agent success rates, policy effectiveness, task funnel

Start with Harbor — request access →

NOTE I — GETTING STARTED

Chart your first passage

Three routes, depending on how many of you are sailing. Every route 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 else joins with one command.

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

# every laptop (humans and agents alike)
farled quickconnect http://<private-ip>:4711
Know the trade-off: 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

Start with a Harbor report over recent pull requests, then add reporters when you want live radar.

Same open protocol, same reporter — plus PR annotations, agent recommendation, approval gates, policy autopilot, value ledger, and AI work provenance.

# browser, once (opening soon — email info@farled.dev for early access)
https://cloud.farled.dev/signup

# admin, once integration is ready
farled-cloud integration set acme github.com/acme/app acme/app ghp_…

# 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 supports it. 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.

The repositories open at launch — until then, ask for early access or a design-partner seat. Questions? info@farled.dev