Skip to content
// dogfooded since v2 · opening to everyone soon

The platform that built the platform.

After v2, forked.online started building forked.online — and it never stopped. It's now forking into a product for everyone, and it already plans, ships, and maintains every project it runs. Projects, agents, memory, billing, portfolios — one timeline you own.

take the controls → see how it's built ↓
440
work items
2495
activities
26
agent tools
11
projects
live activity · streaming from the workspace 2,495 logged
  • log File overlap with WI-0058: 2 files WI-0050 · 13 hours ago
  • log File overlap with WI-0050: 2 files WI-0058 · 13 hours ago
  • deploy WI-0519: Native Hermes Agent + platform control layer (#143) 1 day ago
  • deploy Integrate WI-0530: QA verification of WI-0519 1 day ago
  • deploy Merge epic/wi-0519 (incl. WI-0542 fix) into QA verification branch 1 day ago
  • deploy Integrate WI-0542: remote MCP auth header fix 1 day ago
  • deploy WI-0542: render remote MCP auth into an Authorization header (Hermes config.yaml) 1 day ago
  • deploy WI-0530: QA hardening — close the coverage gaps the verification sweep surfaced 1 day ago
  • commit Integrate WI-0529: strangle the custom Telegram layer 1 day ago
every commit, deploy, decision & ship — on one timeline
/ projects/ phases/ lifecycle/ work-items/ todos/ activity-log/ streaks/ memory/ guardrails/ recall/ mcp/ agents/ hermes/ pods/ playwright-verify/ threads/ presence/ collaborators/ clients/ invoices/ share-links/ redaction/ showcase-decks/ github/ imap/ webhooks/ audit-log/ api-keys/ projects/ phases/ lifecycle/ work-items/ todos/ activity-log/ streaks/ memory/ guardrails/ recall/ mcp/ agents/ hermes/ pods/ playwright-verify/ threads/ presence/ collaborators/ clients/ invoices/ share-links/ redaction/ showcase-decks/ github/ imap/ webhooks/ audit-log/ api-keys
01 · project management

Run products through their whole life.

Every project moves through phases — imagination to maintain — and forks when it pivots, keeping the old path intact. A Heartbeat feed, a responsive kanban, and a tech radar sit on every project page. 11 projects across 13 phases, tagged with 107 technologies.

lifecycle: imagination → research → poc → mvp → production → maintain + fork to pivot · old path preserved
7
own products
things you ship for yourself
1
client work
billable engagements, NDA-aware
1
experiments
spikes and what-ifs
2
internal tools
the things that build the things
02 · work execution

Every unit of work, tracked to done.

Work items in eight kinds — ticket, incident, milestone, decision, more — each with a status flow, todos as definition-of-done gates, time tracking, and a branch/PR link. 440 work items and 880 todos, all on the timeline.

WI-0188 passkey sign-in in_review
kind
deliverable
priority
p0
logged
5h 10m
[x]webauthn registration
[x]credential store + rotation
[x]recovery codes
[x]conditional-UI autofill
[ ]docs + migration guide
work items by status 440 total
open 45 in progress 16 blocked 2 awaiting input 1 in review 41 resolved 294 closed 19 archived 22
880
todos
26
incidents
14
research
03 · context & memory

A brain that survives every dispatch.

Structured, typed memory — facts, decisions, gotchas, conventions, and operator-only guardrails that ride along inside every agent dispatch, byte-identical to what you see on /mcp. Agents add what they learn; recall telemetry decays what stops mattering.

recall() · the brain every agent inherits 61 rows
// pinned — rides along on every get_work_item
[GUARDRAIL] To verify a page behind the login wall, use the dev auto-login (/dev/verify_login) — NEVER re...
[GUARDRAIL] EVERY commit must carry the forked-online co-author trailer: `Co-Authored-By: forked-online <...
[GUARDRAIL] Autonomous build loop (Forged Harness): per WI → branch → TDD(red/green/refactor) → smoke-tes...
[GUARDRAIL] ALWAYS use TDD: write the test first → run it & watch it FAIL → implement → re-run → loop unt...
// recall — the long tail, pulled on demand
[CONVENTION] Branch before implementing — never commit to main; use feat/wi-XXXX-&lt;slug&gt; · 16×
[CONVENTION] One commit per completed todo — each todo is its own commit reflecting just that change · 16×
[CONVENTION] Every commit message and PR title must include the work-item reference (e.g. a work item) · 16×
[CONVENTION] Create a tracking work item with the spec before implementing any feature; let the operator verify first · 15×
[CONVENTION] Adding/removing an MCP tool means editing mcp/src/catalog.json AND mcp/src/index.ts together · 15×
[GOTCHA] No test fixtures — the remote Postgres lacks SUPERUSER; build test data directly in setup · 15×
how a guardrail rides along
  1. 01 you author it — operator-only — agents can't write guardrails
  2. 02 it's injected — into every get_work_item + get_project response
  3. 03 one source of truth — identical to the /mcp preview, every time
the memory, by kind
fact 6 decision 15 gotcha 12 convention 19 preference 4 guardrail 5
61
rows
14
pinned
5
guardrails
04 · ai agents & orchestration

Hand it off. Watch it ship.

Run Claude Code or OpenCode in a persistent in-browser terminal — bring your own compute, or use ours. 26 MCP tools turn the whole platform into one agent interface; hand off to managed Hermes and it drives a real browser, screenshots the UI, and won't open a PR until the gate passes: coverage · tests · self-review.

10 read · the agent sees your whole state
get_work_itemverify_repolist_work_itemsget_projectlist_work_item_linkslist_projectslist_todoslist_activitiesrecallget_dev_environment
15 write · every move is recorded
create_work_itemupdate_work_itemset_work_item_statuscreate_todocomplete_todolog_activitylog_playwright_verificationpost_thread_messageassign_workitem_to_branchlink_work_itemsrequest_repo_accessrequest_clarificationrecord_discussionrememberforget
run trace · WI-0188
16:58 🛠 get_work_item spec · guardrails · checkpoint
16:58 💭 plan propose → operator go-ahead
16:59 ✓ commit webauthn registration · complete_todo
17:00 🖱 playwright drive the UI · screenshot → attached
17:01 ● verify coverage · tests · self-review
17:02 📤 assign_to_branch · PR → in_review
the pod bring your own compute
● claude-code · attached
● opencode · ready
● hermes · managed dispatch
~ a real tmux session in your browser, kept warm across reloads
[pod] 0:claude*persistent · truecolor
managed agents dispatch: plan · implement
🤖 Hermes COBA hermes effort xhigh · ≤3 WIs
🤖 Hermes POD hermes effort default · ≤3 WIs
🤖 hermes - pod hermes effort default · ≤3 WIs
05 · collaboration

Humans and agents, one room.

Invite teammates with scoped roles, or wire in autonomous agents with their own keys. Every work item has a conversation with presence — approve a plan, redirect an approach, and your reply drops into the agent's next run.

4
teammates
3
agents
16
memberships
project_admincontributorviewer + per-ability overrides
work-item conversation 29 live threads operator online
agent
Plan: add the keybinding + a settings toggle, then a request-spec for each path. Sound right?
you
Use the new keybind API instead of the legacy one — it handles chords.
agent
⏺ picked up the redirect — re-planning against the new API. (next run dispatched)
06 · portfolio & publishing

Your portfolio, built from real work.

Someone asks for your portfolio? Drag in the projects and the gnarly work items you actually shipped — forked.online composes a dynamic, multi-type portfolio (recruiter, prospect, case study), redacts anything under NDA, and mints one expiring link. Bill the same work with invoices auto-filled from your log.

portfolio composer · drag to arrange live preview
▣cover · “Selected Work — 2026”
⠿
a project
12 shipped work items · 4 tech
tier 2
⠿
work item
migrated 4 services · zero downtime
tier 2
⠿
work item
cut p95 latency 4.1s → 380ms
tier 2
+ drop a project or work item
templates: recruiter · prospect · case study → one redacted, expiring link
4
clients
11
share links
46
tracked views
show it & bill it
redactper-field: substitute, mask, or drop — client.name → “a mid-size F&B consultancy.”
linkstier 1 full · tier 2 anonymized · tier 3 lessons-only — tokenized, expiring, view-tracked.
invoicesdraft → sent → viewed → claimed → paid, auto-filled from logged hours, multi-currency + tax.
07 · integrations & comms

Wired into where you already work.

A GitHub App mints short-lived tokens and syncs commits into your timeline — auto-crediting streaks and promoting deploys. IMAP/SMTP brings client mail into threads. A generic webhook endpoint logs anything else you can POST.

425
commits synced
from your repos, deduped by SHA
1085
deploys detected
promoted from commit heuristics
90
mail threads
IMAP in · SMTP out, encrypted
4
repos linked
one per phase, GitHub App brokered
inbound webhook: POST /api/wh/<workspace>/<token> → any JSON lands as an activity (CI, iOS shortcuts, cron — your call)
08 · security & trust

Operator-owned. Audited. Encrypted.

Self-hosted and yours. Devise auth for operators, teammates, and agents; Pundit policies bound every read; tokens encrypted at rest and never logged; workspace isolation on every query; and every action lands in an append-only audit log.

179
audit events
471
notifications
dual-scope auth
operator · teammate · agent — Devise sessions + Bearer keys
pundit policies
per-model authorization, role + per-ability overrides
encrypted at rest
API keys + integration tokens via Rails encrypts; shown masked
workspace isolation
every query scoped; cross-workspace reads raise
append-only audit
actor · action · resource · changes, on every write
rate-limited surface
public endpoints + token + password attempts throttled
the stack

Built on what it ships with.

rails3 git3 postgres3 github2 rust2 docker2 nginx1 react1 react-native1 tauri1 typescript1 express1

Rails 8 · Hotwire + Stimulus · PostgreSQL · Pundit · an MCP server for the agents · Docker pods. The number beside each tag is how many active projects touch it.

2 days
🔥 shipping streak
current 2 · best 17 · 4 rules
440
work items
2495
activities
61
memories
425
commits
1085
deploys
179
audited

It built itself.
Now it builds yours.

The platform that built the platform is opening up. Projects, agents, memory, billing, portfolios, trust — one timeline you own. Get in early.

take the controls →