Bug report review in your coding agent

Your agent checks a bug report against the code before you submit. Code, Solidity and draft-report reviews run on your agent’s own model with no account. A free account adds run_review for all 11 review types, one a day on your own key.

Install

Claude Code

Remote endpointNothing to install

Terminal
claude mcp add --transport http bounty-operator https://bountyoperator.com/api/mcp
Run a local server insteadNode 22 or later
Terminal
claude mcp add --transport stdio bounty-operator -- npx -y https://bountyoperator.com/dl/bounty-operator-mcp.tgz

On Windows outside WSL, start it through cmd: end the command with -- cmd /c npx -y and the same address.

Add your account tokenfor account and run_review
Create a free account and tokenOne passkey prompt, no email, no card.

Remote endpoint, in .mcp.json at the root of your project. The two headers carry your account token and your provider key, and Claude Code fills in each ${NAME} from your environment:

.mcp.json
{
  "mcpServers": {
    "bounty-operator": {
      "type": "http",
      "url": "https://bountyoperator.com/api/mcp",
      "headers": {
        "Authorization": "Bearer ${BOUNTY_OPERATOR_TOKEN}",
        "X-Provider-Key": "${OPENROUTER_API_KEY}"
      },
      "timeout": 1200000
    }
  }
}

Local server. The same two values go in as environment variables:

.mcp.json
{
  "mcpServers": {
    "bounty-operator": {
      "command": "npx",
      "args": [
        "-y",
        "https://bountyoperator.com/dl/bounty-operator-mcp.tgz"
      ],
      "env": {
        "BOUNTY_OPERATOR_TOKEN": "${BOUNTY_OPERATOR_TOKEN}",
        "OPENROUTER_API_KEY": "${OPENROUTER_API_KEY}"
      },
      "timeout": 1200000
    }
  }
}

timeout is in milliseconds, and the call ends then even while progress arrives: 1200000 is 20 minutes, above the longest hosted review. claude mcp add has no timeout option, so use the file. If the server is already added, run claude mcp remove bounty-operator first. On Windows outside WSL, start the local server through cmd: "command": "cmd" with "/c", "npx" at the front of args.

Codex

Remote endpointNothing to install

Terminal
codex mcp add bounty-operator --url https://bountyoperator.com/api/mcp
Run a local server insteadNode 22 or later
Terminal
codex mcp add bounty-operator -- npx -y https://bountyoperator.com/dl/bounty-operator-mcp.tgz
Add your account tokenfor account and run_review
Create a free account and tokenOne passkey prompt, no email, no card.

Remote endpoint, in ~/.codex/config.toml. Codex reads both values from your environment:

~/.codex/config.toml
[mcp_servers.bounty-operator]
url = "https://bountyoperator.com/api/mcp"
bearer_token_env_var = "BOUNTY_OPERATOR_TOKEN"
env_http_headers = { "X-Provider-Key" = "OPENROUTER_API_KEY" }
tool_timeout_sec = 1200

Local server:

~/.codex/config.toml
[mcp_servers.bounty-operator]
command = "npx"
args = ["-y", "https://bountyoperator.com/dl/bounty-operator-mcp.tgz"]
env_vars = ["BOUNTY_OPERATOR_TOKEN", "OPENROUTER_API_KEY"]
tool_timeout_sec = 1200

Codex stops a tool call after 60 seconds by default, so keep the tool_timeout_sec line: 1200 seconds is above the longest hosted review. On the remote endpoint a hosted review runs until the model finishes, for up to 15 minutes, and sends progress every 10 seconds. Through the local server it ends within 270 seconds, or runs for up to 15 minutes on a Bounty Operator model, whose first request after a quiet spell can wait up to 10 minutes for the model to start.

Cursor

Remote endpointNothing to install

~/.cursor/mcp.json
{
  "mcpServers": {
    "bounty-operator": {
      "url": "https://bountyoperator.com/api/mcp"
    }
  }
}

Add to CursorOpens Cursor and adds the remote endpoint.

Run a local server insteadNode 22 or later
~/.cursor/mcp.json
{
  "mcpServers": {
    "bounty-operator": {
      "type": "stdio",
      "command": "npx",
      "args": [
        "-y",
        "https://bountyoperator.com/dl/bounty-operator-mcp.tgz"
      ]
    }
  }
}
Add your account tokenfor account and run_review
Create a free account and tokenOne passkey prompt, no email, no card.

Remote endpoint. Cursor fills ${env:NAME} from your environment:

~/.cursor/mcp.json
{
  "mcpServers": {
    "bounty-operator": {
      "url": "https://bountyoperator.com/api/mcp",
      "headers": {
        "Authorization": "Bearer ${env:BOUNTY_OPERATOR_TOKEN}",
        "X-Provider-Key": "${env:OPENROUTER_API_KEY}"
      }
    }
  }
}

Local server:

~/.cursor/mcp.json
{
  "mcpServers": {
    "bounty-operator": {
      "type": "stdio",
      "command": "npx",
      "args": [
        "-y",
        "https://bountyoperator.com/dl/bounty-operator-mcp.tgz"
      ],
      "env": {
        "BOUNTY_OPERATOR_TOKEN": "${env:BOUNTY_OPERATOR_TOKEN}",
        "OPENROUTER_API_KEY": "${env:OPENROUTER_API_KEY}"
      }
    }
  }
}

Use .cursor/mcp.json in a project folder to add the server to that project only.

OpenCode

Remote endpointNothing to install

Check opencode --version. Merge this entry into your project’s config; keep any servers you already use. OpenCode v1 and v2 use different shapes.

opencode.json · v1
{
  "mcp": {
    "bounty-operator": {
      "type": "remote",
      "url": "https://bountyoperator.com/api/mcp",
      "oauth": false
    }
  }
}
OpenCode v2 configuration
opencode.jsonc · v2
{
  "mcp": {
    "servers": {
      "bounty-operator": {
        "type": "remote",
        "url": "https://bountyoperator.com/api/mcp",
        "oauth": false
      }
    }
  }
}
Terminal
opencode mcp list

The server should be connected without signing in. oauth: false disables an unnecessary OAuth flow: the core tools need no credentials, and hosted tools use explicit headers. Your OpenCode model performs the core review; its normal costs and limits still apply.

Run a local server insteadNode 22 or later
opencode.json · v1
{
  "mcp": {
    "bounty-operator": {
      "type": "local",
      "command": [
        "npx",
        "-y",
        "https://bountyoperator.com/dl/bounty-operator-mcp.tgz"
      ]
    }
  }
}
OpenCode v2 local configuration
opencode.jsonc · v2
{
  "mcp": {
    "servers": {
      "bounty-operator": {
        "type": "local",
        "command": [
          "npx",
          "-y",
          "https://bountyoperator.com/dl/bounty-operator-mcp.tgz"
        ]
      }
    }
  }
}

Start OpenCode in the project you want to review. On Windows, if your client cannot launch npx, use ["cmd", "/c", "npx", "-y", "https://bountyoperator.com/dl/bounty-operator-mcp.tgz"] as the command.

Add your account tokenfor account and run_review
Create a free account and tokenOne passkey prompt, no email, no card.

These headers are only for hosted reviews. The free core workflow above does not need them. OpenCode expands {env:NAME} from your environment; never put a real key in the config you share.

opencode.json · v1
{
  "mcp": {
    "bounty-operator": {
      "type": "remote",
      "url": "https://bountyoperator.com/api/mcp",
      "oauth": false,
      "headers": {
        "Authorization": "Bearer {env:BOUNTY_OPERATOR_TOKEN}",
        "X-Provider-Key": "{env:OPENROUTER_API_KEY}"
      },
      "timeout": 1200000
    }
  }
}
OpenCode v2 hosted configuration
opencode.jsonc · v2
{
  "mcp": {
    "servers": {
      "bounty-operator": {
        "type": "remote",
        "url": "https://bountyoperator.com/api/mcp",
        "oauth": false,
        "headers": {
          "Authorization": "Bearer {env:BOUNTY_OPERATOR_TOKEN}",
          "X-Provider-Key": "{env:OPENROUTER_API_KEY}"
        },
        "timeout": {
          "execution": 1200000
        }
      }
    }
  }
}

The timeout is 20 minutes. v1 uses a number; v2 uses timeout.execution. For a local server, put the account token and provider key in environment using the same {env:NAME} syntax.

No account needed for either route. list_profiles, prepare_review for the three core profiles and build_packet work as soon as the server is added. The local package is listed with its SHA-256 in SHA256SUMS.txt.

claude.ai and Claude Desktop stop any tool call after 240 seconds, and a hosted review runs for up to 15 minutes. Run hosted reviews from Claude Code, Codex or the website. prepare_review and build_packet for the three core profiles work in every client.

Ask your agent for a first review

Choose the files first. The agent writes the review; Bounty Operator prepares the request and checks the packet.

Agent request
Use bounty-operator to review the files I choose. If I have not chosen files, ask me which ones. Call list_profiles, then prepare_review with the matching core profile (general, solidity or report). Stop if the privacy check blocks. Write the review from the prepared instructions, then call build_packet with the unchanged manifest. Show the verdict, evidence gaps and reference problems. Do not call run_review or spend provider credit on my behalf.

Watch the MCP workflow in 75 seconds.

75 seconds, no sound. Recorded MCP calls with the public, invented Tessera Staking example. Your agent’s normal model costs apply. Download video
Read the transcript

Codex setup command:

codex mcp add bounty-operator --url https://bountyoperator.com/api/mcp
  1. 00:00 Keep the review in your coding agent: connect the endpoint, challenge a draft, then keep the evidence packet.
  2. 00:06 For Codex, add the remote endpoint with the terminal command below. No local server package is needed. Core report reviews require no Bounty Operator account or provider key.
  3. 00:17 Ask your agent: Use bounty-operator to challenge draft-report.md against src/TesseraStaking.sol and the supplied proof and programme rules. Answer the prepared request, then build the packet. The example sends four public files and programme context. The remote endpoint receives the file text your agent sends.
  4. 00:28 prepare_review returns a privacy check, file hashes and the review request. Your agent’s own model answers that request. The captured response prepared four files with no privacy findings. The screen shows one manifest entry: TesseraStaking.sol, 5,704 bytes and 152 lines, with its SHA-256 hash.
  5. 00:40 The Codex review says rewrite, then submit: reward theft is supported; principal theft and permanent principal lock are not. It cites TesseraStaking.sol lines 110–118. claim() rejects a payout above rewardReserve. The synthetic programme rules classify theft of unclaimed rewards as Medium. This capture reviewed the source; it did not rerun the supplied test.
  6. 00:53 build_packet checks citation locations and creates a Markdown packet. The captured result has ok: true, verdict: rewrite-then-submit and an empty referenceProblems list. It retains the four-file manifest and SHA-256 hashes. Valid citation locations do not by themselves prove a vulnerability.
  7. 01:07 Keep your workflow and the evidence. This core review uses your agent’s own model, with no Bounty Operator account. Your agent’s normal model costs apply. Hosted reviews are a separate route. Setup is at bountyoperator.com/mcp.

The tools it exposes

The remote endpoint exposes five tools. Three run with no account, so an agent can prepare a review and package the result on the first call. The local server adds a sixth, run_gauntlet_plan, and reads files by path.

Code security review, Solidity review and Challenge a draft report are the three core profiles. prepare_review hands their request to your agent’s own model. Every other profile runs on the hosted service through run_review, and so do seven of the gauntlet’s stages.

  • list_profiles

    No account

    The review profiles and what each one needs as input. Every profile carries hosted: false for a core profile, true for a hosted one.

  • prepare_review

    No account

    For the three core profiles: runs the privacy check on the files, then returns a SHA-256 manifest and the exact review request. Your agent’s own model answers it. A hosted profile is refused with hosted_profile.

  • run_gauntlet_plan

    No accountLocal server

    The eight gauntlet stages in order, the Context fields still empty and the call that ends the run. The plan names the tool that runs each stage.

  • build_packet

    No account

    Turns a finished review into the evidence packet: the manifest with hashes, your context, the review and a link to verify it.

  • account

    Account token

    Your plan, the reviews used today and when the allowance resets.

  • run_review

    Account tokenProvider key

    A hosted review of any profile on the provider and model you name, and the only way to run a hosted profile. Returns the review, the manifest and your remaining allowance.

A call takes up to 50 text files, 120 KB per file, 240 KB and 20,000 lines in total. File names are repo-relative paths such as src/Vault.sol. When the privacy check blocks a file, the result lists the file, the line and the kind of match, and never the matched text.

The remote endpoint takes file text inline as files. On the local server, prepare_review and run_review also take paths: the server reads those files under its working directory, so your agent does not send the text. A client that starts the server outside your project sets BOUNTY_OPERATOR_ROOT to the project folder.

Core and hosted profiles

list_profiles marks every profile. hosted: false is one of the three core profiles: its method is open source and prepare_review hands it to your agent. hosted: true is a hosted profile: the service adds its method when run_review runs and sends it with your files to the provider you named, under your key. It is not in the local package or in the public repository, and no tool or prompt returns it.

For a hosted profile the tools answer like this:

  • list_profiles

    The profile with its name, its description, the inputs it reads and hosted: true.

  • prepare_review

    A failed call with the code hosted_profile, the profile id and a sentence that names run_review. It is refused before any file is read.

  • run_review

    The review, its verdict, the reference check, the manifest and your remaining allowance. It uses one hosted review. A review the provider blocks under its usage policy comes back with blocked set and is not counted. verdict and panel run on Operator only.

  • build_packet

    The evidence packet for the review run_review returned. Pass source: "ai".

The refusal, as the remote endpoint returns it for triage:

prepare_review
{
  "profile": "triage",
  "error": "Triager simulation runs on the server. Call run_review with profile \"triage\", your connection token and your provider key in the X-Provider-Key header.",
  "code": "hosted_profile"
}

The local server returns the same code and names BOUNTY_OPERATOR_TOKEN in the sentence. run_review sends the files and your provider key to the service, which adds the method of the profile, calls your provider and returns the review.

Three slash commands

The server ships three prompts. A client that supports MCP prompts lists them as commands. In Claude Code, type / and pick one, or type the full name:

  • /mcp__bounty-operator__challenge-report

    Checks every claim in your draft report against the code it cites, then builds the evidence packet.

  • /mcp__bounty-operator__solidity-review

    Maps entry points and invariants in the contracts you name and reports what the code proves, with file and line.

  • /mcp__bounty-operator__gauntlet

    Takes a finding through the pre-submission stages in order and ends with one verdict. Its hosted stages run through run_review.

challenge-report and solidity-review prepare the review with prepare_review, have your agent’s own model answer and end with build_packet, so both work with no account.

gauntlet lists the eight stages with the tool that runs each one. Seven are hosted and run through run_review. The report stage is a core profile, so your agent’s own model answers it from prepare_review. The run needs an account token and your provider key, and it uses seven hosted reviews. Free covers one hosted review per UTC day, so a full run takes Operator. On the local server the prompt starts from run_gauntlet_plan.

Skills and the plugin

The repository is also a Claude Code plugin with five skills. challenge-report, solidity-review and code-security-review carry the three core methods and run on your agent’s own model with no account. gauntlet runs the eight stages through this server. hunt-with-gate runs only when you call it by name: it checks a finding before any report is written and never submits anything.

Terminal
claude plugin marketplace add bountyoperator/bounty-operator
claude plugin install bounty-operator@bounty-operator

The plugin adds this server too. It reads BOUNTY_OPERATOR_TOKEN and BOUNTY_OPERATOR_PROVIDER_KEY from the environment you start Claude Code in; both can stay unset for the core skills. Codex, Cursor and other agents take the skills with one command and the server with the commands above:

Terminal
npx skills add bountyoperator/bounty-operator

With Immunefi Studio’s MCP server

Immunefi Studio runs its own MCP server. Add it next to Bounty Operator, rather than replacing either server. The gauntlet and report challenge use Studio evidence when the relevant feature is already available on your account. Studio is hosted by Immunefi; there is no Studio package here to upgrade.

  • Programme rules: list_programs finds a name and slug, not the assets, impacts, exclusions or rules. The workflows collect those from the official programme pages or your supplied rules, with source URLs and retrieval time. Missing rules stay a gap.
  • Blueprint: list_blueprints finds available reports. Start with get_blueprint section overview, choose the finding’s chainId, then read relevant sections and their cited files with list_blueprint_sources and get_blueprint_source. The report challenge and gauntlet keep those as evidence, compare them with the finding’s revision, and treat suggested leads as hypotheses—not proof or bounty scope.
  • Instascope: the gauntlet calls get_proxy_history and get_target_state with the programme slug and the affected Instascope asset id. State is a captured getter snapshot at a block, not an arbitrary live read. An unavailable snapshot, a changed implementation or null upgrade history stays an explicit limitation.
  • Signals: when you ask about target selection or recent programme changes, the gauntlet skill can use get_signal and programme-filtered list_signal_updates. A partial page is not a complete history; null or withheld metrics are unknown, not zero. Signals do not establish scope or predict a payout.

An existing Studio Review can be another reviewer’s notes. Cases and tasks are optional: the gauntlet writes to your Studio workspace only when you say yes. No workflow starts a trial, unlocks a programme or changes a Studio subscription.

If you already connected Studio, keep that connection. Otherwise, create a personal access token on Studio’s agents page. It starts with stu_ and acts as you, so keep it in an environment variable. Your agent sends it to Immunefi; Bounty Operator never receives it. Do not put the token or account details in review files.

Terminal
claude mcp add --transport http immunefi-studio https://studio.immunefi.com/api/mcp --header "Authorization: Bearer $IMMUNEFI_STUDIO_TOKEN"
~/.codex/config.toml
[mcp_servers.immunefi-studio]
url = "https://studio.immunefi.com/api/mcp"
bearer_token_env_var = "IMMUNEFI_STUDIO_TOKEN"
~/.cursor/mcp.json
{
  "mcpServers": {
    "immunefi-studio": {
      "url": "https://studio.immunefi.com/api/mcp",
      "headers": {
        "Authorization": "Bearer ${env:IMMUNEFI_STUDIO_TOKEN}"
      }
    }
  }
}

Restart your agent after adding the server, then ask “Who am I in Studio?” It should call whoami and identify the account you intended. Blueprint, Instascope, Studio Review and Signals have their own access requirements. If a feature is unavailable, the workflows state the gap and continue without that enrichment.

Checked against Immunefi’s live 35-tool catalogue on 20 October 2026. The official agents page is the setup and tool reference. Immunefi controls that server and its access rules; a Studio token does not grant a Bounty Operator subscription, or the reverse.

What needs an account token

Works with no token

  • list_profiles
  • prepare_review, for the three core profiles
  • build_packet
  • run_gauntlet_plan, on the local server
  • The challenge-report and solidity-review prompts

Your agent’s own model does the review. Nothing is counted against an allowance.

Needs a token

  • account
  • run_review, with your provider key
  • The gauntlet prompt, which runs its hosted stages with run_review

A hosted review uses the same allowance as the website: one per UTC day on Free, unlimited on Operator at US$10 per month.

Create a token

Create a free account and tokenOne passkey prompt, no email, no card.
  1. Create a free account at bountyoperator.com with a passkey, or sign in with yours. The account panel opens on Connections.
  2. Name the connection after the client that will use it, and create it.
  3. Copy the token. It starts with bok_ and is shown once.
  4. Set it as BOUNTY_OPERATOR_TOKEN in your environment and add the server with the token command for your client.

A token lasts 90 days. An account holds three at a time. Revoke one in the account panel and it stops working at once.

Your provider key

run_review runs on your own AI provider API key. The remote endpoint takes it in the X-Provider-Key header. The local server reads it from the provider’s environment variable:

ProviderEnvironment variable
OpenRouterOPENROUTER_API_KEY
AnthropicANTHROPIC_API_KEY
OpenAIOPENAI_API_KEY
Google GeminiGEMINI_API_KEY
xAIXAI_API_KEY
DeepSeekDEEPSEEK_API_KEY
MistralMISTRAL_API_KEY
GroqGROQ_API_KEY
Novita AINOVITA_API_KEY
Nebius Token FactoryNEBIUS_API_KEY
InfronINFRON_API_KEY
OrcaRouterORCAROUTER_API_KEY
Bounty OperatorBOUNTYOPERATOR_API_KEY

The remote endpoint uses the provider’s default model when a call names none. The local server needs a model: pass model, or set BOUNTY_OPERATOR_MODEL.

What the server can reach

  • A token does two things

    It reads your usage and runs a review. Billing, passkeys, recovery and deletion stay behind your passkey. We keep a SHA-256 of the token, its label and its last-used time.

  • The server sees what your agent passes

    The remote endpoint receives file contents as tool arguments and nothing else from your machine. The local server reads only the paths your agent names under its working directory.

  • A hosted review goes through our server

    The run_review tool sends the files and your provider key to bountyoperator.com. The server adds the method of the profile, calls your provider and returns the review. It stores none of it.

  • Keys stay out of the transcript

    The provider key travels in a header or an environment variable, never as a tool argument.

  • Stateless endpoint

    Each request stands alone. There is no MCP session to resume and no stream held open.

  • Local means local

    On the local server, preparing a review, planning a gauntlet and building a packet run on your machine with no network call.

The security page has the full data flow, what is stored and how to report a vulnerability.

When a call fails

A failed tool call comes back as a result with isError set and one JSON object: error, a sentence your agent can act on, and code, a value that does not change. Both servers use the same codes.

  • hosted_profile

    prepare_review was called with a hosted profile. Nothing was read and nothing was counted. Call run_review.

  • privacy_block

    The privacy check found a secret. The result lists the file, the line and the kind of each match. Remove it and call again.

  • privacy_warn

    The privacy check found an email or an IP address. Call again with acknowledgeWarnings: true to send the files as they are.

  • daily_used

    The free review of the day is used. The result carries resetsAt, the time the next one opens.

  • operator_only

    run_review was called with verdict or panel on an account without Operator. Those two profiles run only inside the gauntlet and a panel review. Nothing was sent to the provider and the review of the day is not used.

  • review_running

    The account is running as many reviews as its plan allows. Call again when one finishes.

  • provider

    Your provider rejected the key or the model, had no credit, hit a rate limit, failed or timed out. The review is not counted.

  • provider_policy

    Your provider blocked the request under its usage policy. The key is not the cause and the review is not counted. Call again with another model or provider, not the same one.

  • output_withheld

    The model repeated its instructions instead of reviewing, so the answer was stopped and the call used one review. Run it again or choose a stronger model.

account and run_review without a valid token are answered with HTTP 401 by the remote endpoint, which is what makes a client ask for the token. The local server returns the code token.

Questions

Do I need an account to use the MCP server?

No. list_profiles, prepare_review and build_packet work with no account and no key, and so do the challenge-report and solidity-review prompts: your agent’s own model answers the prepared request of a core profile. An account token adds account, run_review for every profile, and the gauntlet prompt.

Should I use the remote endpoint or the local server?

The remote endpoint needs nothing installed and works on any machine the client runs on. The local server needs Node 22 or later, keeps review preparation on your machine, reads files by path and adds run_gauntlet_plan. The other five tools are the same on both.

What does a hosted review cost through MCP?

run_review shares one allowance with the website: one hosted review per UTC day on Free, any profile, and unlimited on Operator at US$10 per month. Operator includes US$2 Bounty Operator API credit per paid month. A gauntlet run over MCP uses seven hosted reviews, one for every stage but the report stage, so a full run takes Operator. Copy-paste reviews in a chat app do not count, and neither do code, Solidity and draft-report reviews your coding agent’s own model writes with prepare_review or the skills. Those need no account. Other model providers bill usage to your key.

Which profiles can my agent’s own model run?

The three core profiles: Code security review, Solidity review and Challenge a draft report. prepare_review returns their method and the request. Every other profile is hosted: prepare_review refuses it with hosted_profile and run_review runs it on the service, on your provider key.

How much output can a hosted model use?

Reasoning and the answer share one output allowance. A streamed review (the website, and run_review from a client that reads a stream) gives the listed models that take it 64,000 tokens: Claude Opus 5.5, Sonnet 5.5 and Fable 5.1, GPT-6.1 Sol, Astra and Luna, Grok 4.7, and the models in the OpenRouter list. On OpenRouter, Gemini 3.8 Flash, Qwen3.8 27B, Qwen3.8 Max 0902, HY4 Preview and GLM 5.3 get 64,000 on every call. Everything else, including a model id you type and a call read as one answer, has 16,000. Reasoning defaults are preserved. Your provider bills the tokens used, so the larger allowance costs more only when the model needs it. The direct Gemini endpoint uses its provider allowance.

How do I check the service before a long run?

GET https://bountyoperator.com/api/health returns the version, reviews (whether hosted reviews are on) and profiles. profiles reads hosted when the service carries the full method of every hosted profile. A Worker built from the public repository reads community: it runs the hosted profiles on short stand-in instructions.

Which clients work?

Any client that speaks MCP over Streamable HTTP or stdio. This page has the commands for Claude Code, Codex and Cursor.

Is the server in the MCP Registry?

Yes. The official MCP Registry lists the remote endpoint as io.github.bountyoperator/bounty-operator. The entry is published from the source repository by a GitHub workflow that signs in as the repository, so the name on the registry and the code on GitHub have one owner.

Prefer a browser

The website runs the same profiles with the same engine, and shows each finding as a card.