Reuse first.
Build only the gap.

Give ReuseForge a goal and a USD budget. It plans the cheapest sound route: reuse an open-source item, buy a listed one, or build what is missing. Escrow holds payment until you confirm; it runs in test mode on a self-hosted node and in the simulator. Checkout on the hosted app is coming soon.

Plan a goal in the app Read the docs

Registry for code, skills, harnesses, MCP servers
Signed ledger on self-hosted nodes
MIT licensed

planner / try it, nothing to sign up for Runs locally. Your goal is not sent.

Pareto frontier

Plan 1 of 4 $27.00 92% Recommended

recommended

Total cost: $27.00of $50.00 budget
Estimated fit: 92%tests, stars, ratings
Risk: Low · 0.20licence and seller

Recommended plan: one row per need
Need	Item	Licence	Price	Fit
Document parsing	doclingrepo	MIT	Free	96%
Web front end	SaaS Starter UIrepo DEMO	Commercial-Single-Project	$12.00	88%
Crypto payments	Crypto Checkout Kitskill DEMO	Commercial-Single-Project	$15.00	92%
LLM chat	llama_indexrepo	MIT	Free	86%
Payments	Crypto Checkout Kitskill DEMO	Commercial-Single-Project	same item	92%
Retrieval (RAG)	llama_indexrepo	MIT	same item	97%
Total, shared items counted once			$27.00	92%

2 paid items would be held in escrow until you accept them (test mode, no real money). Checkout on the hosted app is coming soon.

This is the plan for the example goal. Turn on JavaScript to edit the goal and budget.

Free items are real open-source projects from a small bundled set. Items marked DEMO are examples and cannot be bought. Fit and risk are heuristics. Open the full planner

How it works

Designed so nothing is paid until you accept.

The plan runs on the hosted app today. The steps after it (escrow, delivery, payout) run on a self-hosted node and in the simulator, in test mode: no real money moves. On a node each step is an event on a signed ledger, so the buyer, the sellers and the escrow agent can each check what happened. On the hosted app, checkout is coming soon.

01
Goal and budget
Say what you want in plain words and set a USD cap. Leave the cap empty to see every option.
02
Plan
The planner splits the goal into needs. For each one it picks an item to reuse, an item to buy, or a gap to build. You get the whole trade-off between quality, cost and risk, not one answer.
03
Escrow
On a node, paid items become one order. The buyer's deposit is confirmed by the escrow agent and the order shows as funded.
04
You confirm
Sellers deliver. You check the work, then accept it or open a dispute inside the window.
05
Sellers are paid
On acceptance each seller receives the price minus the network fee (default 1%). Refunds go back to the buyer in full. All in test mode.

The escrow state machine

These are the states in repoblock/escrow.py, the escrow of a self-hosted node. Only the buyer can cancel, accept or dispute. Only an item's own seller can deliver it. Only the named escrow agent confirms deposits and resolves disputes. Steps by anyone else are ignored when the log is read.

QUOTEDtoFUNDED: The escrow agent confirms the deposit and the amount must equal the order total.
FUNDEDtoDELIVERED: Each seller delivers its own item with an access link and a content hash. The order is delivered once every item is.
DELIVEREDtoRELEASED: The buyer accepts, or stays silent past the acceptance window (7 days by default). Silence releases payment so sellers are protected too.
FUNDEDtoREFUNDED: If delivery is not complete by the deadline (7 days by default), the buyer is refunded in full.
FUNDED or DELIVEREDtoDISPUTED: Only the buyer can dispute. The arbiter named on the order then resolves it as a release or a refund.
QUOTEDtoCANCELLED: The buyer can cancel before funding. Both windows are set per order; 7 days is the default in the code.

A real receipt and its log

The example plan above buys two DEMO items. This is what the reference node wrote when we ran that order end to end on the simulated rail, in test mode. Identifiers are shortened.

Receiptord_e5dad1b2f11a4f8c

SaaS Starter UI: $12.00
Crypto Checkout Kit: $15.00

Held in escrow: $27.00
Paid: SaaS Starter UI: $11.88
Paid: Crypto Checkout Kit: $14.85
Network fee, 1%: $0.27

stateRELEASED

Rail: mock. No real money moved.

ledger / order.* events6 events

  # event          by      id            parent
 14 order.create   buyer   6323352473d8  4bc09e6792ac
 15 order.fund     escrow  da39015db99e  6323352473d8
 16 order.deliver  seller  fd159914884b  da39015db99e
 17 order.deliver  seller  8c02f508aacf  fd159914884b
 18 order.accept   buyer   90e8fb9f27a6  8c02f508aacf
 19 order.settled  escrow  d3fd62b5b128  90e8fb9f27a6

On a self-hosted node, each event is signed by its author and named by the SHA-256 of its content. It also lists the ids of the events it follows, so changing history changes every id after it. Nodes merge their logs by taking the union. The hosted app does not use this ledger.

Why reuse

Agents keep rewriting code that already exists.

A coding agent that cannot find a good library writes its own. That is code someone has to review, test and maintain, and a bigger codebase for the next agent to read. ReuseForge makes the existing option easy to find, with its price and licence shown before the agent starts typing.

rewrite vs reuseexample plan above

need: document-parsing

The agent writes its own invoice PDF parserNew code to review, test and maintain

The agent reuses docling MIT, $0.00Found by the planner, licence shown

need: crypto-payments

The agent writes its own checkout and escrow flowMoney handling nobody has audited

The agent buys Crypto Checkout Kit DEMO, $15.00Held in escrow until you accept, in test mode

need: nothing fits

Build only that partA build brief says what to write, with papers as blueprints

Research

Can Agents Design Libraries for Agents?

Orlanski, Trost, Zhang, Chen, Schmidt, Sala, Albarghouthi

The authors build a benchmark of 15 library tasks and 242 downstream problems. In a separate hand-labelled sample, 41% of the lines that agents rebuilt duplicated functionality the library already had but that was hidden, broken or hard to reach.

The paper studies libraries designed by agents, not ReuseForge, and its results cover its own tasks and settings. We cite it for the problem: discovery and reuse, not missing capability, are often the bottleneck.

For agents

An MCP server and a CLI, not just a website.

On a self-hosted node an agent can search the registry, ask for a plan, pull the pieces and build only what is missing. The bundled assemble_goal prompt tells it to ask you before it pays and before it accepts a delivery. The hosted app also serves MCP at /mcp; its order and payout tools are not implemented yet.

.mcp.json

{
  "mcpServers": {
    "reuseforge": {
      "command": "python",
      "args": ["-m", "repoblock", "mcp"],
      "env": { "PYTHONPATH": "/path/to/Claude-1" }
    }
  }
}

Stdio transport. Point PYTHONPATH at your clone of the repo after pip install -r requirements.txt. A node you run also serves the same tools over POST /mcp.

shell

git clone https://github.com/Longfordjames/Claude-1 && cd Claude-1
pip install -r requirements.txt
python -m repoblock seed
python -m repoblock plan "RAG chatbot over my PDF invoices with a dashboard and crypto checkout" --budget 50
python -m repoblock mcp-config "RAG chatbot over my PDF invoices with a dashboard and crypto checkout"
python -m repoblock mcp

plan prints the recommended plan as JSON. mcp-config prints the .mcp.json your agent needs to carry it out. seed loads the example items; paid ones are labelled DEMO.

Read tools open on a public node

search_blocks
get_block
plan_goal
discover_external
mcp_config
build_brief
list_connectors
list_projects
get_project
portfolio

Write tools admin token over HTTP

create_order
pay_order
accept_order
back_project
vote_milestone

pay_order uses the simulated rail today. Over stdio you are the owner of the node; over HTTP, tools that sign or move money need the node's admin token. An item is called a block in the node, so tool, file and field names keep that word.

For sellers

Publish once, version as you go.

An item is a record of what it is, which licence it ships under and what it costs. On the hosted app you publish one with a form or import a public GitHub repository. Selling is coming soon: nobody can buy a paid item there yet.

Licence, price and files live on the item. The planner counts an unknown licence as risk, so a clear licence ranks better.
Every version has a content hash. Each version you publish on the hosted app records a SHA-256 hash over its files.
On a node, attest your tests. verify runs an item's tests in a throwaway directory and signs the result on the ledger. The pass rate feeds ranking.
On a node, paid on accepted orders. The network fee is 1% by default and the node operator can change it. It comes out of the price, never on top of it. Test mode: no fee is charged yet.

Item price$15.00

Network fee, 1%-$0.15

Seller receives$14.85

Example for a node in test mode. Amounts are rounded down to the cent. Payout addresses are per rail: USDC on Base, USDT on Ethereum or BTC. See pricing.

block.json

{
  "name": "Crypto Checkout Kit",
  "kind": "skill",
  "summary": "USDC, USDT and Bitcoin checkout with escrow.",
  "url": "https://example.com/your/repo",
  "capabilities": ["crypto-payments", "payments"],
  "license": "Commercial-Single-Project",
  "price_usd": 15,
  "payout": {
    "usdc-base": "0xYourAddress",
    "btc": "bc1qyouraddress"
  },
  "content_hash": "sha256:your-release-hash"
}

shell

python -m repoblock publish block.json
python -m repoblock verify <block_id>

This file and these commands are for a self-hosted node. On the hosted app, use the Publish form, Import from GitHub or the API. See Selling an item.

Crowdfunded builds

When nothing fits, fund the build together.

Funded builds are coming soon on the hosted app. Today they run in test mode in the simulator and on a self-hosted node; the docs explain the rules. Many backers fund one goal and developers are hired for its deliverables. Backers receive revenue units in proportion to what they put in, and every later paid sale of the finished item is split across unit holders. Backers approve each milestone by majority of their units. If the goal is not met by the deadline, every backer is refunded.

1,000,000revenue units per project

50% maxof units that developers can hold

> 50%of backer units must approve a milestone

Legal note.Revenue units that people can trade may count as regulated securities in many places. Funded builds run on a simulated rail only. Get legal advice before using real funds or promoting a project.

Trust and status

Built so you can check the work.

The mechanisms are in the open source repo. Each card says whether it belongs to the hosted app or to a self-hosted node, and the status below says plainly how far along they are.

Accounts, sessions and tokens

On the hosted app you sign in with a password or GitHub, and you can turn on two-factor sign-in with an authenticator app (TOTP). API tokens carry scopes, are shown once and can be revoked.

worker/src/modules/accounts

Content hashes on versions

On the hosted app, every published version records a SHA-256 content hash over its files. Static security scans of published code are planned and not built yet.

worker/src/modules/items/versions.js

Signed, append-only ledger

On a self-hosted node, orders, items, attestations and votes are events signed by their authors and addressed by hash. Anyone can verify a log without trusting the node that served it.

repoblock/ledger.py

Escrow before payment

On a node, in test mode, the buyer's money is held until the buyer accepts, the window ends, or an arbiter rules. The rules are enforced when the log is folded, not by a promise.

repoblock/escrow.py

Test attestations

On a node, a verifier can run an item's own tests and sign the outcome. Ranking reads that pass rate instead of a seller's claim.

repoblock/verify.py

Licence-aware planner

Unknown licences and unreviewed sellers add risk, and the plan shows the licence of every item it picks. Fit and risk are heuristics, so read the table before you pay.

repoblock/planner.py, worker/src/planner.js

Stage

Public beta

Expect rough edges. The code is MIT licensed and open to read.

Payments

Test mode

The default rail is simulated, and the hosted app takes no payments: checkout, orders, earnings and funded builds are coming soon. On a node, the USDC, USDT and BTC rails build payment links. Do not send real funds.

Escrow contract

Unaudited, not deployed

The contract is specified in docs/PAYMENTS.md; only its interface is in the repository. It needs an independent audit before it holds money.

FAQ

Questions people ask first.

Short, honest answers about money, timing and what the planner can and cannot do.

Is real money involved?

No. ReuseForge is a public beta and payments run in test mode: no real money moves anywhere. Please do not send real funds. Items marked DEMO have placeholder payout addresses.

Can I buy something on reuseforge.com today?

Not yet. Checkout, orders, earnings and funded builds are coming soon on the hosted app. You can search, plan, publish and import items now, and try escrow and funded builds in the simulator.

Who holds the money while an order is open?

On a self-hosted node, the escrow agent named on the order (test mode). It confirms the deposit and moves the funds when the order is released or refunded. The hosted app has no orders yet. The on-chain version of that role is a smart contract, which is unaudited and not deployed.

What if the seller never delivers?

On a node, if every item is not delivered by the delivery deadline, the order is refunded to the buyer in full. The default deadline is 7 days and it is set per order.

What if I forget to accept?

On a node, after the acceptance window, 7 days by default, a delivered order is released and the sellers are paid. If something is wrong, open a dispute before the window ends and the arbiter decides.

How does the planner choose?

It splits your goal into needs by keyword, ranks items for each need by text match, declared capability and quality signals (tests, stars, ratings), then keeps every plan that no other plan beats on quality, cost and risk. The recommended plan is the best quality minus a small risk penalty, cheaper on ties.

It is keyword based and can miss or mis-rank. Read the table before you buy.

Are the items in the planner real?

The free ones are real open-source projects from a small bundled set. The paid ones marked DEMO are examples with placeholder payout addresses. They show how pricing and escrow work and cannot be bought.

Can I list my own code and what does it cost?

Yes. On the hosted app, create an account, then publish an item or import a GitHub repository. On a node, publish a JSON file with python -m repoblock publish. There is no listing fee in the code. The design takes a network fee, 1% by default, from the price of each accepted paid order; nothing is charged in test mode.

Is crowdfunding a build legal?

That depends on where you are. Revenue units that people can trade may be regulated securities in many jurisdictions. Funded builds are coming soon on the hosted app and today run on a simulated rail only, in the simulator and on a node. Get legal advice before real funds or public promotion.

Plan your next build before you write it.

Paste a goal, set a budget, and see what already exists. It takes a minute and costs nothing.

Open the app Read the docs View on GitHub

Reuse first.Build only the gap.

Live planner