Ellora
Ellora checks writing before it ships. It reviews a draft against the team's saved brand-voice profile (VoiceDNA), strips flat/generic AI phrasing (AI Editor), and enforces the rules in a writing brief (Editorial). It runs as a hosted MCP server, so writers keep writing in whatever LLM app they already use.
| MCP server | https://api.getellora.com/v1/external/mcp |
| Transport | Remote HTTP (Streamable HTTP) |
| Auth | OAuth only — there is no API key to paste |
| Surface | 12 tools + 1 prompt, all prefixed ellora_ |
| App (team admin) | https://app.getellora.com — voice profiles, briefs, tokens |
| Website / demo | https://getellora.com |
| Skill repo | https://github.com/getellora/agent-skills (the same file is served at https://getellora.com/SKILL.md) |
Create account for the Free plan at https://app.getellora.com/register. Verify your email with the code or magic link. The Free plan includes one voice profile and does not include team members. Accounts created before the Free plan launched keep their Team plan.
Team is for in-house teams that need more voice profiles and members.
Email us at hello@getellora.com or set up a call at https://cal.com/getellorademo/client-demo. The dashboard Pricing page and https://getellora.com/#pricing list the plans (no prices shown) and the same schedule-call path. Ellora can upgrade your existing account once we've talked.
First: work out which state you are in
Do this once, at the start, before anything else. Everything below branches off the answer.
- Are the
ellora_*tools available in this session? Callellora_profiles_fetch_activeto find out.- The call returns successfully — an object with a
voice_profilesarray, possibly empty → State 3, connected. - The call returns
401/403, or the client reports the server needs authentication → State 2, go authenticate. - The tools do not exist, or the server is not configured → State 2, go install.
- The call returns successfully — an object with a
- State 2 could become State 1. If the user cannot complete the OAuth sign-in because they do not have an Ellora account, stop and go to State 1. Never fake the connection, and never stub out review results.
Tell the user which state you found, in one sentence, and what you are doing about it. Then do it.
State 1 — The user has no Ellora account
Direct them to https://app.getellora.com/register and Create account on the Free plan. They enter their email, tick the box to accept the Terms (https://getellora.com/terms/) and Privacy Policy (https://getellora.com/privacy/), and verify the code or magic link sent to their inbox. The user must read and accept the terms themselves: never tick the box, accept, or sign up on their behalf. Do not ask them to share the code in chat or claim the account exists before verification succeeds. If they already have an account, this signs them in without changing their plan or creating another workspace.
Once signed in, continue with State 2 to connect their LLM app through OAuth. The Free plan supports one voice profile and no additional team members. If a profile already exists, use it; do not create another profile or workspace to bypass the limit.
For Team access:
Email us at hello@getellora.com or set up a call at https://cal.com/getellorademo/client-demo. The dashboard Pricing page and https://getellora.com/#pricing list the plans (no prices shown) and provide the same schedule-call path.
If signup or authentication fails, report the actual error and offer to continue without Ellora's review. Never present unreviewed output as reviewed.
State 2 — Ellora is not connected yet
1. Add the MCP server
Add a remote HTTP server named ellora pointing at
https://api.getellora.com/v1/external/mcp. Pick the row that matches the
client you are running in.
CLI clients
| Client | Command |
|---|---|
| Command Code | cmd mcp add --transport http ellora https://api.getellora.com/v1/external/mcp |
| Claude Code | claude mcp add --transport http ellora https://api.getellora.com/v1/external/mcp |
OpenCode uses its own mcp block, not mcpServers:
{
"$schema": "https://opencode.ai/config.json",
"mcp": {
"ellora": {
"type": "remote",
"url": "https://api.getellora.com/v1/external/mcp"
}
}
}
Put that in opencode.json in the project, or in
~/.config/opencode/opencode.json for every project. Then run
opencode mcp auth ellora.
Config-file clients (Cursor, Windsurf, Cline, and most others): add this entry to the client's MCP settings, then restart it.
{
"mcpServers": {
"ellora": {
"type": "streamableHttp",
"url": "https://api.getellora.com/v1/external/mcp"
}
}
}
VS Code needs its own shape: "type": "http" (not streamableHttp),
under a servers key instead of mcpServers:
{
"servers": {
"ellora": {
"type": "http",
"url": "https://api.getellora.com/v1/external/mcp"
}
}
}
Claude Code can instead install the Ellora plugin, which adds this server and
this skill together: claude plugin marketplace add getellora/agent-skills,
then claude plugin install ellora@getellora. A server added that way is
listed as plugin:ellora:ellora.
OpenCode can load the same skill from this repository: run
npx skills add getellora/agent-skills -a opencode (add -g for a global
install), or copy skills/ellora to .agents/skills/ellora/ or
~/.config/opencode/skills/ellora/.
Hosted chat clients (ChatGPT, Claude Desktop, claude.ai, Perplexity, and similar): open the client's connector/MCP settings, choose to add a custom remote connector, and give it the URL above. No headers, no keys.
Any other agent: the two facts you need are the URL and the shape — it is a remote HTTP MCP server that authenticates with OAuth. Configure it however that client configures remote MCP servers; don't guess at a token.
2. Authenticate
OAuth is the only auth path, so the client has to run the flow — you cannot curl it into place.
- Command Code:
cmd mcp auth ellora, or run/mcpand authenticate. - Claude Code: run
/mcpand authenticateellora. A server you added withclaude mcp addalso acceptsclaude mcp login ellora; one installed through the Ellora plugin is listed asplugin:ellora:ellora, so use/mcp. - OpenCode:
opencode mcp auth ellora, or run/mcpand authenticate. - Other clients: trigger a connect/authenticate action and follow the browser prompt.
A browser opens on app.getellora.com. The user signs in and approves the
connection; tokens are then stored and refreshed by the client. If no browser
opens, print the URL and have them open it manually, then paste the callback
URL back. Verify afterwards (re-run the check from "First", or
cmd mcp list / /mcp / opencode mcp list) that the server shows
connected, not needs authentication.
If the user has no account, go to State 1 to register. If an existing account cannot sign in, report the error and direct them to hello@getellora.com; registration does not bypass a suspended account.
State 3 — Connected: write with Ellora on
This is the standing default from here on: whenever you are drafting or substantially rewriting prose of the covered kinds, run the review loop before you present the draft to the user. Not only when they say "Ellora" — the point is that it is always on, so the first version they see is already on-voice and deslopped.
Covered: blog posts and articles · landing-page and website copy · launch and release announcements · customer-facing emails · docs for an external audience · social posts · newsletters · decks and outreach.
Skip: code, config, commit messages, internal scratch notes, quick chat replies, and anything the user calls a rough throwaway. When it is genuinely borderline, ask once: "Want me to run this through the Ellora voice check?"
When the connection is new, confirm it in one line and put it to work — say what you'll do (run every draft through the voice check) and get on with the user's actual writing task.
The review loop
Fuller version: the ellora-review skill, if it is installed. Same sequence
also lives on the server as the ellora_review_loop MCP prompt.
Pick a voice profile —
ellora_profiles_fetch_active. One → use it. Several → ask which (teams commonly keep one per writer, or per author they want to sound like). None → a team admin can create one withellora_profile_createfrom 2–20 samples of the team's own writing, then use the returnedvoice_profile_id. Don't send them elsewhere to build one, and never review without one — an id has to resolve to a saved, active profile. If the user isn't an admin and none exists, stop and say a profile has to be created first; that's a real blocker, not something to work around.Pick a writing brief —
ellora_briefs_fetch_active. Same pattern. If there is none, build an inlinewriting_brief_jsonfor this session only (never saved). A brief is mandatory —ellora_session_startfails without either awriting_brief_idor awriting_brief_json. Pass the JSON as an object, not a string. Required fields:version("1"),audience,intent,format.formatis one ofgeneral,social,deck,outreach,blog,audit,website.Start the session —
ellora_session_startwith those two. They are locked for the whole session. Keep the returnedcontent_session_idand pass it to every later call for this one piece of content. While you're there, self-report the optionalmodel_name/model_class/model_version/thinking_effortandmcp_client_name/mcp_client_version— analytics-only, never affects the review.Optionally pull positioning —
ellora_positioning_recommendations, before drafting. Advisory only.Review —
ellora_reviewwith thecontent_session_idand the current draft ascontent. It takes no profile or brief argument of its own — both are already locked into the session.contentis capped at 100,000 characters, so split anything longer into successive pieces.Do what
next_actionsays.keep_rewriting→ rewrite using the response's ownrewrite_guidance, then go back to step 5 with the samecontent_session_id. Do not show the draft to the user yet — you are mid-loop.ready_to_verify→ no mandatory finding remains. Check this same response: it already carries averificationblock comparing the content against the session's first-reviewed content — unless this was the session's very first call, in which case there is nothing yet to compare against (treat it likekeep_rewritingif findings remain, or deliver as-is if there are none). Don't run another pass just to get verified. Deliver onceverification.passed: true.diminishing_returns→ the rewrites stopped helping, or you hitmax_iterations. Stop looping, tell the user exactly what is still flagged, and ask how to proceed.
Blue findings never gate. Severity
blue(counted separately incurrent_finding_counts.blue) are optional AI-Editor suggestions: they never makenext_actionkeep_rewritingand are never a reason to run another pass. Apply or ignore them as you see fit.Verification and learning are automatic. A passing call that isn't the session's first already carries the
verificationblock, and on success against a saved profile alearning_event. There is no separate verify call to make.Teach the profile only on explicit approval. If the user accepts the delivered rewrite and approves the rules you extracted from it, call
ellora_learn_from_accepted_rewritewithuser_approved: true. Never on your own inference.
Keep going around 5 → 6 → 7 until step 6 sends you out of the loop. Don't stop
early because the draft "seems good enough" — the iteration / max_iterations
budget exists so you can keep going with confidence.
One session = one piece of content. A different article, or a switch to another
profile or brief, means a new ellora_session_start.
When the loop finishes, present the final draft plus a short summary: how many passes it took, what changed at a high level, and anything still flagged that you chose to leave. Don't dump raw finding JSON unless asked.
Tools
| Tool | Use it for |
|---|---|
ellora_session_start |
Open a session for one piece of writing; locks in profile + brief |
ellora_review |
Review the draft; auto-inlines rewrite guidance, auto-verifies |
ellora_learn_from_accepted_rewrite |
Save a human-approved rule (never on inference) |
ellora_profile_create |
Admin-only. Create a voice profile from 2–20 samples |
ellora_profiles_fetch_active / _by_id |
Find a usable voice profile id |
ellora_briefs_fetch_active / _by_id |
Find a usable writing brief id |
ellora_context_fetch_active / _by_id |
Read the team's company context docs |
ellora_context_capture |
Save a context doc mid-session (admin activates it) |
ellora_positioning_recommendations |
Advisory messaging/positioning guidance |
Prompts: ellora_review_loop.
Rules
- Never invent results. If the tools aren't connected, say so and carry on
without Ellora. Do not describe a finding, a score, or a
passedverdict you did not get back fromellora_review. - Don't route around access or plan limits. Signup requires accepting the terms and verifying the email; connection requires OAuth. The Free plan permits one voice profile and no team members. See the dashboard Pricing page or https://getellora.com/#pricing for Team plans (listed without prices). Email us at hello@getellora.com or set up a call at https://cal.com/getellorademo/client-demo.
- Don't show unreviewed drafts as reviewed, and don't claim a piece passed
when you stopped on
diminishing_returns. - Follow
next_action, not your own judgment, about whether to keep looping. - A brief is mandatory. If the team has none, build the inline
writing_brief_jsonrather than skipping the review. - One piece of content, one session.