FounderReply

Architecture & guarantees

How “nothing goes out until you approve it” is enforced

The product pages make one promise. This page shows where the code keeps it: which component decides whether an action may run, where a draft waits, what can move it, and how the credentials that finally send it are stored.

  • A queued draft is sent only by an approval that claims it from pending
  • Autonomy is resolved per workspace, action and network when the action runs
  • An API key can make the dial stricter, never looser
  • Connected-account tokens are sealed with AES-256-GCM, bound to their workspace
Scheduled postMCP tool callAPI briefGrowth commentControllerworkspace × action × networkoffapproveautoresolved when the action runsoffapproveautoSkippedthe reason is keptApprovalspendingwaits for a person(or an approve-scope key)Guardrailsyour rules · moderationany violationyou ✓passConnector sendsfrom your own accountthe result is recordedsent · or failed, with why

Overview

The path of a write

Every outbound action — a scheduled post, a reply, a DM, a comment under someone else’s post — has the same three possible fates, decided by one controller. The figure above is the whole model; the sections below take it apart.

Off off

The action is skipped. Discovery and drafting still run; nothing is sent, and the controller’s reason is kept on the item.

Approve approve

The draft is written to the approval queue as pending and waits there. This is where every action starts.

Auto auto

Sent without review — but only after guardrails and moderation pass. Any violation sends it to the queue instead.

Queue

A draft leaves the queue only by being claimed

Writes that need a person are stored as queue items with status pending. Approving one is a two-step operation, and the first step is what makes it safe to approve from two places at once — the dashboard, a teammate’s phone, a reviewer agent.

Written as
pending — by the scheduler, a growth run, an MCP write tool, or a v1 brief
Approve
Refused unless the item is pending. Then one conditional update moves it pending → approved; the caller that gets no row back sends nothing.
Edit
You may change the text while approving. What ships is your text, and that is what gets classified and logged.
After the claim
Plan gates run (publishing needs a paid plan; the Free reply allowance is reserved atomically and refunded if the send fails), then the connector sends.
Ends as
sent, with the platform’s id — or failed, with the reason. Rejected items never send.
The claimlib/approval.ts
-- approveAndSend(id) — before any gate or send
UPDATE approval_queue
   SET status = 'approved', error = NULL
 WHERE id = $1
   AND status = 'pending'
RETURNING id;
-- no row back → "already being processed", nothing is sent
The double-send guard: two concurrent approvals both read pending, only one gets the row back.

Who can approve

A signed-in member in the dashboard, or an API key minted by an owner or admin with the opt-in approve scope. Any other key gets error -32002 with a link to the queue. Every key-made decision is recorded against that key.

Autonomy

The dial is resolved when the action runs, not when it was planned

The controller answers one question for a (workspace, action, network): off, approve or auto. The scheduler asks it for every post at the moment it would publish, and a growth run asks it for every comment — so turning the dial down stops what was already planned.

Resolutionlib/autonomy.ts
// lib/autonomy.ts — decide(workspace, action, platform)
platformDefault = PLATFORM_CAPS[platform][action] ?? 'approve'
setting         = autonomy_settings(workspace, action)   // may be absent

mode = setting ?? minMode(DEFAULT_MODES[action], platformDefault)
beyondPlatformDefault = setting is looser than platformDefault
Your setting
Stored per workspace and action, and returned as you set it. The network’s policy is a default, not a ceiling.
No setting
The safer of our default and the network’s own policy — so an absent opinion never lands outside a network’s rules.
Looser than policy
Allowed, and flagged: the decision carries a beyond-platform-default flag and a reason naming the rule it crosses.
Before auto
Your banned topics, link and length rules, and a moderation pass. A violation — or a moderation check that could not run — queues the action for a person.
Where each action starts, per network, derived from the controller's tables
NetworkPostReplyDMComment on others
Redditapproveapproveapproveoff
Instagramapprovepolicy: autoapprovepolicy: autoapproveoffpolicy: approve
Facebookapprovepolicy: autoapprovepolicy: autoapproveoffpolicy: approve
LinkedInapprovepolicy: autoapproveapproveoff
Xapprovepolicy: autoapprovepolicy: autoapproveoffpolicy: approve
Blueskyapprovepolicy: autoapprovepolicy: autoapproveoffpolicy: approve
YouTubeapproveapproveapproveoffpolicy: approve
Stack Exchangeapproveapproveapproveoffpolicy: approve
Lemmyapprovepolicy: autoapprovepolicy: autoapproveoffpolicy: approve
Discourseapprovepolicy: autoapprovepolicy: autoapproveoffpolicy: approve

Nothing starts on auto on any network. Where a network’s own policy would allow more, it is shown as “policy”: that is the line a looser setting of yours is measured against.

Keys

A key can lower the dial, never raise it

An fr_live_ key is bound to one workspace when it is minted, carries only the scopes it was minted with, and is stored as a SHA-256 hash — the plaintext is shown once and never again. Only an owner or admin can mint one.

read · default
List and read: drafts, queue items, analytics, the registry. Also what keeps an approval webhook firing.
draft · default
Create drafts and queue items — every social write tool enqueues — run audits and research, reject a queue item. Default on a new key.
publish
Opt-in. Tools that act on your own published content or a browser task directly: cross-posting an already-published article, refreshing or editing a live article, running a goal on a web page. Never social posts, replies or DMs.
admin
Opt-in. Workspace configuration — syndication targets, relationships, and set_autonomy, which can still only lower a mode.
approve
Opt-in. Approving a queue item sends it, so it is never on by default.
-32001
The key lacks the scope this tool needs. The message names the scope and where to mint a key that has it.
-32002
No key may do this as asked: raising an autonomy mode, or approving without the approve scope. The error carries the dashboard link.
HTTP 401
Missing or revoked key. Revoking takes effect on the next request.
Webhook
A key can register one “something is waiting” webhook. It is signed with HMAC-SHA256 and carries no draft text — only what is waiting and where to read it.
Responsetools/call set_autonomy {mode: auto}
{
  "jsonrpc": "2.0",
  "id": 7,
  "error": {
    "code": -32002,
    "message": "set_autonomy: an API key can only lower autonomy (reply is 'approve'; 'auto' would raise it). Raise it in the dashboard: …/dashboard/autonomy",
    "data": { "tool": "set_autonomy", "human_only": true, "dashboard_url": "…/dashboard/autonomy" }
  }
}
Errors come back at HTTP 200 inside the JSON-RPC envelope.

Credentials

Tokens are sealed, and sealed to their workspace

Your network passwords never reach FounderReply — you sign in to each network yourself, in a real browser session, and the browser service keeps that session. Any account token or secret FounderReply does store is encrypted at rest with AES-256-GCM before it is written. The associated data binds each ciphertext to its table, column and workspace, so a blob copied into another tenant’s row fails authentication instead of decrypting.

Stored formatlib/crypto.ts
v2.<base64( 0x02 ‖ kid ‖ iv[12] ‖ ciphertext ‖ tag[16] )>

AES-256-GCM, Web Crypto (runs on the Workers runtime)
iv   96-bit, crypto.getRandomValues, fresh per encryption
aad  0x02 ‖ kid ‖ "brand_accounts:<column>:<workspace_id>"
Cipher
AES-256-GCM through Web Crypto: 256-bit keys, a fresh 96-bit random IV per encryption, a 128-bit tag.
Bound to
The version byte, the key id and the table:column:workspace context, all authenticated.
Rotation
A key ring by id. New writes use the active key; older rows still decrypt under theirs until they are re-encrypted, and only then is the old key retired.
API keys
Never encrypted, because never stored: only the SHA-256 hash is kept.

Honesty

Where the queue is not in the path

A guarantee is only useful if its edges are stated. These are the five ways something goes out without a person approving that exact item — each one a choice someone in your workspace made.

You raised the dial

An action set to auto in the dashboard sends without review, after guardrails and moderation. Only a signed-in member can raise it.

You published it yourself

A signed-in member sending finished content to the publish route without asking for approval — the API twin of “Publish now”. No API key reaches that route.

A key with the approve scope

An owner or admin can mint a key that approves queue items — for a reviewer agent. The decision is recorded against the key.

Press pitches that earned it

After fifteen consecutive pitches approved without an edit, pitches send directly; about one in twenty still goes through the queue, and any edit or rejection turns it off. A key’s approvals never count toward it.

A key with the publish scope

Opt-in tools that act on your own blog and browser tasks directly — cross-posting an article that is already published, refreshing or editing a live article in place, driving a goal on a web page. None of them posts, replies or sends DMs on a social network; those always go through the queue.

Everything else — every MCP write tool, every v1 brief, every scheduled action on a gated setting — waits in the queue. See the MCP tool registry for what each tool does.

Build on it

Automate the work. Keep the approval.

Mint a key, point your agent at the MCP endpoint, and every write it makes waits in the same queue you already approve from.

Free to start · Approval on by default · No card required