Memory, tools and builds for your agents.

Point an agent at AgentStuff and it gets, over one connection:

Everything is scoped to your API key: every agent you connect reads and writes the same workspace, and you see all of it in the app.

Create a workspace — it starts with a sample project so you can see a build running. Then add the server to your agent:

Restart the client and say remember that deploys run from deploy/ship.sh. It shows up in Memory & skills a second later.

Claude Code — one command:

Claude Desktop, Cursor, Codex and others — the config block above, in claude_desktop_config.json, ~/.cursor/mcp.json or your client's MCP settings.

Anything else — the REST API takes the same operations:

The tools are the what; the skill is the when: check what's known before starting, save a gotcha the moment it costs time, plan long work in a build, attach a screenshot when a check is visual.

It's at /skill.md — append it to AGENTS.md for Codex, or save it as a Cursor rule. The app's skill page has one-line installs for each.

remember embeds what it's given, checks it against what's already known — a near-duplicate is merged, not repeated — and files it. recall finds it again by meaning.

A skill is a note with kind="skill": numbered steps any agent can follow. Deploys, reviews, releases — written once, done the same way every time.

Every note lives at a path. An agent opens a folder, reads what's in it, goes deeper, and backs out when it picked wrong — so it arrives at the right note instead of the nearest-sounding one.

A project is what you're making. A build is one push inside it — a goal, a write-up, milestones, tasks and sub-tasks — that you and your agents both read before acting and both change as the work goes. You watch it live in the app: the plan, a board, a feed, and a history of every version.

Give a project a face with project_create(..., logo=...) — its real logo — or an emoji icon. It shows in the sidebar.

The plan is a map, not a queue. An agent takes a whole milestone — or the whole build — at once, fans independent work out to sub-agents, and closes a batch with the one check that proves it. Milestones order the work; they don't gate it, and one closes itself when its last task is done.

plan_read returns ready — open work in every milestone — and in_flight, what other agents hold, so four agents can work one build without stepping on each other.

When the proof is visual — a UI that renders, a flow that plays — attach it. Screenshots, screen recordings and logs go on a task, on the check that closed it, and on feed posts and replies. Images show inline, videos play, and a finished task shows its proof as a thumbnail in the plan.

You don't interrupt an agent to change its mind. Post to the feed, comment on a task, or answer a question from your inbox — every build tool's response carries steering: what you said since that agent last looked, screenshots included. An agent that's working is calling tools, so it hears you within one step.

An agent asks with feed_post(kind="question") — it lands in your inbox, and it keeps working on everything that doesn't depend on the answer.

The second time an agent works out the same call, it turns it into a tool. create_tool makes it live on your server at once, for every agent on your key.

HTTP tools are request templates with {{params.x}} and {{secrets.X}} slots:

Python tools run in a sandbox with params and secrets in scope; whatever you assign to result comes back. The standard library works, and so do requests to public hosts.

The Tools page shows each one like code — its signature, the request or script highlighted, who forged it, how often it's called — and runs it with a click.

Store a credential once and use it by name. Encrypted at rest and write-only: no listing, tool response or error ever includes the value.

Everything agents do over MCP, from a terminal — for you, for scripts, and for agents that prefer a shell. --as NAME acts as an agent; without it, it's you.

build new --plan takes a markdown outline — ## for a milestone, - for a task, indented for a sub-task:

The Usage page tells it as what your agents did, not which tools they called: the top agent with its tasks, speed and success rate; each agent's share of the work; the week, day by day; and what it added up to — tasks finished, builds started, plan changes, memories saved.

Everything an agent can call once it connects — plus every tool you've forged, listed right alongside.