ScriptGrain MCP tool reference: every tool the server exposes

By Jack Stovell · published 2026-09-21 · checked 2026-09-20

The server at mcp.scriptgrain.com/mcp exposes 30 tools and two prompts on every plan, including Free. Reading, scoring and comparing cost nothing. Drafting, polishing, humanising, rewriting a page and building a profile spend credits or an extraction slot. That's the whole shape of it.

Connecting

Two ways in: a bearer header, or OAuth. The server advertises OAuth resource metadata, so clients that support dynamic registration will register themselves and hand you a consent page to sign into once. Everyone else uses the header.

For Claude Code, run this from a terminal:

`claude mcp add scriptgrain https://mcp.scriptgrain.com/mcp --transport http --header "Authorization: Bearer sg_live_…"`

On claude.ai, it's Settings, then Connectors, then Add custom connector. Paste the URL, sign in when the consent page opens. Same pattern on ChatGPT, where connectors are available on the plan: Settings, Connectors, Add custom connector, paste the URL, sign in.

Gemini CLI wants the server declared in `settings.json`:

{ "mcpServers": { "scriptgrain": { "httpUrl": "https://mcp.scriptgrain.com/mcp", "headers": { "Authorization": "Bearer sg_live_…" } } } }

Meta Muse takes the same endpoint as a custom integration. Cursor and other MCP clients want the URL plus the bearer header, no different from Claude Code in spirit. Legacy SSE clients can still reach the server at `/sse`, though the streamable HTTP endpoint is the one to use going forward.

Your key starts `sg_live_` and gets minted in Settings, then API. It's shown once. Write it down somewhere sane.

The tools

Thirty tools, one server. They split cleanly into three jobs: build and query a voice profile, generate and check content against it, manage the account underneath. `list_profiles`, `create_profile`, `get_profile` cover the first. `generate_content`, `check_voice_match`, `compare_voice`, `polish`, `humanize`, `ai_detect`, `save_edit`, `rewrite_page`, `mimic_brand` cover the second. `list_companies`, `create_company`, `get_billing`, `get_invoice`, `upgrade_plan` cover the third.

Then there's memory: `get_memory`, `sync_memory`, `add_to_memory`, `set_repeat_policy`, `check_novelty`, `what_next`. These exist so a profile doesn't repeat itself across a hundred pieces, and so it knows what's already been written before it drafts the hundred and first.

Rounding it out: `list_generations`, `get_generation`, `create_outline`, `get_voice_monitor`, `add_monitor_url`, `remove_monitor_url`, `run_voice_monitor`. The table below lists all 30 against what each one costs.

Free tools

Reading and scoring cost nothing. That's the rule, and it holds without exception: `check_voice_match`, `compare_voice`, `ai_detect`, `save_edit`, `create_outline`, `list_profiles`, `get_profile`, `list_generations`, `get_generation`, `list_companies`, `get_billing`, `get_invoice` all run free on every plan. `get_memory`, `what_next`, `check_novelty` and the voice monitor tools sit here too.

Rate limits still apply even where money doesn't. Sixty requests a minute per key across the board. Voice match scoring gets its own ceiling of 200 an hour, generous enough that you'd need to be scoring obsessively to hit it. Compare that with profile extraction, capped at 5 an hour per account, which tells you where the actual cost sits in the system.

Tools that spend credits

Six tools spend a credit or a slot, and only six. `create_profile` uses one extraction slot, not a credit, which matters if you're watching a credit balance and wondering why it didn't move. `generate_content` spends 1 credit per variant, so asking for three variants of the same brief spends three. `polish` and `humanize` are 1 credit each, but both skip the charge entirely if the piece already passes the target, so running them speculatively costs nothing if there's nothing to fix.

`rewrite_page` is priced by length: 1 credit per 1,500 words. `mimic_brand` spends 1 brand-mimic credit and needs explicit consent before it runs, since it's mimicking someone else's voice rather than yours. None of the memory tools spend anything. Neither does billing.

The two prompts

Two prompts ship alongside the tools: `write_in_my_voice` and `build_my_voice_profile`. They're not separate endpoints so much as scripted sequences, a way of calling the tools in the right order without wiring it up yourself each time.

`build_my_voice_profile` walks through gathering samples and calling `create_profile`, then polling `get_profile` until the job's done. `write_in_my_voice` takes a finished profile and runs it through `generate_content`, then `check_voice_match`, in the order you'd do it by hand anyway. Useful if your client supports prompts as a first-class thing. Skippable if it doesn't; the underlying tools work exactly the same either way.

A typical session

Start with three samples, each 50 to 5,000 words, 50,000 words total across the profile. Call `create_profile`. It returns a `profile_id` and a `job_id`, status `processing`, because building a profile isn't instant.

Poll `get_profile` until it stops saying `processing`. While it runs you'll see `progress_percent` tick upward; when it's done you get a narrative description, a `confidence_score`, and the full 45-attribute attributes object. That object is the profile, read live over the API each time, not something exported once and left to go stale.

From there, `generate_content`. Pass the `profile_id`, a brief up to 8,000 characters, a content type from the 16 on offer (article, linkedin, newsletter, email, and so on), and optionally a register: formal, professional, conversational, casual. Set an `english_variant` if it matters, `uk` or `us`. Set a `word_count_target` between 50 and 4,000 words if you want a length, and the output lands within 15% either way, with `within_tolerance` reported back so you know whether it hit.

Then `check_voice_match`. It scores 0 to 1 against the profile, with notes and a `deltas` array breaking the score down by feature: label, similarity, weight, whether it's salient, a detail string, word count. If the score comes back under 0.85, run `polish`. It's 1 credit, free if the piece already clears the bar, so there's no cost in trying it even when you're not sure it's needed.

Once the piece is right, `save_edit`. Free, and it feeds the closed loop: the edited final goes back into what the profile learns from, so the next piece starts from a slightly better place than this one did. That's the whole point of `save_edit` existing as a separate call rather than folding the edit silently into the generation record.

For the next piece, the memory tools do the carrying. `get_memory` shows what the profile already knows about past pieces. `check_novelty` flags whether a new draft is repeating itself. `what_next` suggests where to point the profile based on what it hasn't covered yet. `sync_memory` and `add_to_memory` keep that record current as pieces get written and saved. None of that costs a credit either. The loop, stripped to its bones: `create_profile`, `generate_content`, `check_voice_match`, `save_edit`. Everything else in the 30 tools exists to make that loop sharper the second time round.

Limits

Tool names and costs are read from the server as it stood on 2026-09-20 and can change with a release; the changelog line on the API documentation records moves. Client support for remote MCP servers, OAuth and prompts varies by client and by plan (ChatGPT connectors are not on every plan; the Gemini app has no connector), so a route that works in Claude Code may need the bearer-header form elsewhere.

Questions

Does the MCP server work on the Free plan?

Yes. All 30 tools and both prompts are available on every plan, Free included. What changes between plans is the [rate and credit ceiling](/reference/api-plan-limits), not which tools you can reach. Reading, scoring and comparing stay free regardless of plan; drafting and polishing spend from whatever balance the plan provides.

What happens if I call generate_content three times with the same brief?

If you're asking for three variants in one call, that's 3 credits, one per variant. If you're calling `generate_content` three separate times, each call spends its own credit unless you're using the same `Idempotency-Key` header, in which case a retry replays the stored response with no second charge.

Can I connect more than one client to the same profile?

Yes. A profile lives behind your `profile_id` and is read live through the API, so Claude, ChatGPT, Gemini CLI, Cursor and Muse can all query the same profile independently. There's no per-client copy to keep in sync. Whichever client calls `get_profile` gets the same attributes object back.

Why did create_profile return a job_id instead of the profile straight away?

Because extraction isn't instant. `create_profile` returns a `profile_id` and a `job_id` with status `processing`, and you poll `get_profile` until it completes. Extraction is capped at 5 an hour per account, which is the tighter limit in the whole system, tighter than generation or voice matching by a wide margin.

What's the difference between polish and humanize?

Both cost 1 credit and both skip the charge if the piece already passes. `polish` targets voice match against the profile; `humanize` targets how the text reads against AI detection, checked separately through `ai_detect`, which is free to run as often as you like against any piece.

Methodology

Tool names, costs and REST equivalents are read from the MCP worker source (version 1.15.0) and docs/api/mcp.md as of 2026-09-20.

Sources

• ScriptGrain MCP documentation
• ScriptGrain: Writing voice can be measured (the 45 attributes)
• ScriptGrain API reference (v1)
• ScriptGrain research index (SGR studies)