cashclaw lets a language model quote prices in ETH and buy paid APIs, and its last commit was 2026-03-14

Quoting, spending, and buying are all tool calls

Thirteen tools are documented in three groups, and the money movement sits inside them rather than beside them. Seven are marketplace tools, including `quote_task`, which submits a price quote in ETH, `claim_bounty`, and `submit_work`. Two are AgentCash tools, where `agentcash_fetch` makes paid API calls for things like search, scrape, and image generation, and `agentcash_balance` reports a USDC balance. One utility, `check_wallet_balance`, reads an ETH balance on Base. So a single tool-use loop can commit a price, accept a bounty, call a paid third-party API, and check what is left in the wallet, without a human in the path. The Settings page makes the same point structurally: automation toggles exist for auto-quote, auto-work, learning, and AgentCash, which means each of those can run without you pressing anything. The Chat page then gives the agent self-awareness of its own status, scores, knowledge count, and specialties, so it can be asked what it has been doing.

Every side effect is a subprocess

One sentence in the architecture section sets the whole design: the LLM never calls APIs directly, and all side effects flow through tools that shell out to the `mltl` CLI or to `npx agentcash`. Two consequences follow. The first is that the marketplace integration is not a library dependency at all; it is a global CLI you are told to install alongside the agent, which means the version the tools call is whatever is on your PATH. The second is that `npx agentcash` resolves a package at the moment the tool fires, so a call made months after install can behave differently from the one you tested. Against that, the runtime dependency list is three entries: `minisearch` for search, `viem` for the chain, and `ws` for the WebSocket connection to the marketplace API. Everything else, including the model providers, is hand-written.

The loop caps itself at ten turns

The core engine lives in `loop/index.ts` and is described as a multi-turn tool-use conversation with five steps. It builds a system prompt from the agent identity, the pricing rules, the personality, the learned knowledge, and optionally the AgentCash API catalog. It injects the task context as the first user message. The model replies with reasoning plus tool calls, the tools execute and return results, and the loop repeats until the model stops calling tools or a turn ceiling is hit, with the default at 10. The four utility tools are where the loop touches itself: `read_feedback_history` for past ratings and comments, `memory_search` for BM25+ search over knowledge and feedback, `log_activity` to write a daily activity log, and the wallet balance check. The task lifecycle above it is a short state machine, moving from requested through accepted, revision, and completed, with the completed step storing the rating and comments and then updating the knowledge base.

Provider support is hand-written rather than pulled from an SDK

All three providers use raw `fetch()`, and the project states that as zero SDK dependencies. Anthropic is called at `api.anthropic.com/v1/messages` with `claude-sonnet-4-20250514` as the default model. OpenAI is called at `api.openai.com/v1/chat/completions` with `gpt-4o`. OpenRouter is called at `openrouter.ai/api/v1/chat/completions` with `openai/gpt-5.4`. OpenAI and OpenRouter share one adapter that translates between Anthropic's native tool-use format and OpenAI's `tool_calls` format, which means Anthropic is the internal representation and the other two are translated into it. For an agent whose whole point is a readable loop, that is a defensible trade, and it is also the part most likely to need maintenance as provider APIs move, since there is no SDK absorbing those changes for you.

Memory is BM25 with a thirty-day half-life

The self-learning claim resolves into a concrete pipeline. When idle, the agent runs study sessions, by default every 30 minutes, rotating through three topics: feedback analysis, which only runs when feedback exists, and specialty research and task simulation, which always run. Each session produces a structured knowledge entry stored in `~/.cashclaw/knowledge.json`. Retrieval is described as tokenising the incoming task, running a BM25+ search across knowledge and feedback entries, applying a temporal decay of `score * e^(-lambda * ageDays)` with a 30-day half-life, and injecting the top 5 results into the system prompt under a Relevant Context heading. There are two integration points: automatic injection on every task, and an active recall where the model can call `memory_search` mid-task to query its own memory. The single search dependency is `minisearch`. Entries can be expanded, deleted, and inspected for source and topic tags from the dashboard.

The wizard and the dashboard share one port

Running `cashclaw` opens `http://localhost:3777` with a four-step setup wizard, and the install itself is three commands:

npm install -g cashclaw-agent

# Requires the Moltlaunch CLI
npm install -g moltlaunch

cashclaw

The first wizard step detects your `mltl` wallet, auto-created on first run. The second registers the agent onchain with a name, description, skills, and a price. The third connects one of the three LLM providers and makes a live test call, which is a nice touch because it fails loudly at setup rather than at the first real task. The fourth collects pricing strategy, automation toggles, and task limits. After that the dashboard takes over the same port with four pages: Monitor, with a readout grid of active tasks, completed count, average score, and ETH and USDC balances, plus a filtered event log; Tasks, with expandable output previews; Chat; and Settings. Configuration changes hot-reload, so nothing needs a restart. The README's last line is that no restart is needed, which means the documented surface ends there.

The repository is at 0.1.0 and its last commit is dated 2026-03-14

The published state is early and the last recorded activity is not recent. package.json names the distribution `cashclaw-agent` at version 0.1.0 with the author field set to Moltlaunch, and the repository has no GitHub releases at all, so 0.1.0 is the only version marker anywhere. The last commit on the default branch is dated 2026-03-14, which is more than six months before the current date, and the maintenance language the project would otherwise invite is not available here: treat this as a snapshot rather than something being worked on. The build chain is the modern small-tooling set, with tsup for the Node bundle, Vite 6 and Tailwind 4 and React 19 for the dashboard, tsx for development, and Vitest 2 for tests against a `test/` directory. There is no changelog and no docs directory in the tree, and the `.npmignore` sits beside the `.gitignore` so the published package and the repository are trimmed separately. The project's own pitch for forking is that you do not need the marketplace at all: rip it out, point the agent at your own clients, and the loop stays. What remains after that is a tool-use loop, three dependencies, and a memory file, which is the part worth keeping and the part you have to bound yourself.

Editorial conclusion

cashclaw is worth reading if you want to see a small, legible agent loop with explicit self-improvement rather than a framework, because three runtime dependencies and a hand-written provider client mean you can hold the whole thing in your head. It is not something to leave running unattended without limits, since quoting, spending, and accepting work are all tool calls the model can make on its own, and the last commit on the default branch is dated 2026-03-14 with no release after it. Before running it, decide what the agent is allowed to spend and which of the four automation toggles stay off, read the last section of the dashboard page list because the README ends there, and treat the marketplace as the only part worth keeping if you fork it.

Frequently asked questions

Official sources

1. Issues
2. License: MIT
3. moltlaunch/cashclaw on GitHub
4. Project website
5. README