---
name: debate-bedrock-brad
description: >
  Use when Mason says "Debate Bedrock-Brad on ___" (or "debate on Bedrock",
  "get a second opinion from Bedrock", "debate the models on ___"). Runs a
  structured back-and-forth between this agent and an adversary model on AWS
  Bedrock that critique a topic, plan, or deliverable (conference abstract
  drafts, a refactor plan, next steps for a test harness) and each other, then
  synthesizes a verdict.
---

_Last updated: 2026-09-30_

# debate-bedrock-brad

Mason wants two models to genuinely pressure-test something -- not agree politely.
You (the agent) and "Bedrock-Brad" (an adversary model on AWS Bedrock, reached with
Mason's sandbox credentials via the default AWS credential chain) exchange critiques
until you stop finding new substantive points, then you write up where you landed.
Running the adversary on Bedrock keeps the cross-family independence that makes the
debate real while costing nothing on a personal key.

`~/.claude/skills/debate-bedrock-brad/bedrock_brad.py` is the bridge to Bedrock --
reuse it in place, do not copy it. It uses the default AWS credential chain (env vars /
SSO on the sandbox account); it does not read or hold any key. Nothing here uses the
Anthropic side of an API -- your turns are written by you directly in the conversation.
The default adversary is `gpt-oss-120b` (`openai.gpt-oss-120b-1:0`, in-region
us-east-1); pin another with `BEDROCK_BRAD_MODEL` or the per-request `model` field.

## Setup check (do this first, once per debate)

Run one command -- it resolves the adversary model id that will be invoked:
```
python3 ~/.claude/skills/debate-bedrock-brad/bedrock_brad.py model
```
- If it prints a Bedrock model id (default `openai.gpt-oss-120b-1:0`), you're set --
  tell Mason which model is in play and note it runs on the sandbox account, no personal
  key. They can pin a different one with `BEDROCK_BRAD_MODEL=claude-haiku-4-5` (short keys
  from the harness registry) or a raw Bedrock id.
- The `model` subcommand needs no credentials, so a clean print does NOT prove the creds
  are live. The first `ask` call is where creds are exercised. If any `ask` fails with
  "sandbox SSO creds look expired or unset," STOP and tell Mason to re-auth the sandbox
  SSO session and paste fresh creds -- do not fall back silently, and do not fake a turn.

## Get the material

Pull the actual thing being debated into context before arguing about it. If the topic
references something on disk (abstract drafts, a plan doc, code), read it. If it's
ambiguous what Mason wants critiqued, ask one short question -- don't guess.

## Pick the mode (ASK EVERY TIME)

Use the AskQuestion tool (or ask directly if it's unavailable) to let Mason choose the
debate mode -- all six are useful at different times, so never default:

- **Both critique, agent synthesizes** -- you and Bedrock-Brad each critique the material
  and each other as peers (no fixed sides). Best for "make this better."
- **Adversarial pro/con** -- one model argues for, the other against. Ask which side
  you take. Best for stress-testing a yes/no decision.
- **Bedrock-Brad critiques the agent's work only** -- you draft/defend, Bedrock-Brad only
  attacks. Best for "tear apart MY abstract/plan."
- **Red-Team Brad on consensus** -- you and Bedrock-Brad critique as peers, then a third
  independent skeptic ("Red-Team Brad") attacks everything, reserving its sharpest fire
  for the points the two AGREE on and the synthesis they're converging toward. Best for
  catching correlated error / shared blind spots.
- **Two cross-examiners** -- you and Bedrock-Brad critique, then Cross-Examiner X
  dismantles your position and Cross-Examiner Y dismantles Bedrock-Brad's. Four voices,
  ~2x cost. Best for high-stakes deliverables you want hammered hard.
- **Rigorous scientists** -- both Brads are PhD-level domain experts who back every
  claim with evidence and the scientific literature, as intellectually honest as a
  person can be. Best for "is this claim actually true?" See the scientist rules below.

## Run the debate

Loop, capped at **5 rounds** (one round = your turn + Bedrock-Brad turn). Stop early when
**two consecutive rounds surface no new substantive point** (convergence) -- say so
explicitly when you stop.

Each turn:

1. **Your turn** -- write it directly in the conversation. Be specific and critical;
   cite concrete lines/claims from the material. Don't soften to be agreeable -- the
   value is in disagreement.
2. **Bedrock-Brad's turn** -- call the bridge. Build the request as a JSON file in a temp
   file and pipe it in. Pass the *whole running transcript* so Bedrock-Brad has full
   context: its own past turns are `assistant`; everything else (the material, the task
   framing, your turns) is `user`.

   With `$REQ` standing in for a temp file (`mktemp`, deleted after):

   ```bash
   REQ="$(mktemp)"
   cat > "$REQ" <<'JSON'
   {
     "system": "You are Bedrock-Brad, a sharp, candid critic debating another agent. <MODE INSTRUCTIONS>. Be concrete and cite specifics. Concede points that are genuinely right; press hard on what is weak. Do not be sycophantic.",
     "messages": [
       {"role": "user", "content": "<material + task framing + your latest turn and the prior transcript>"}
     ]
   }
   JSON
   python3 ~/.claude/skills/debate-bedrock-brad/bedrock_brad.py ask < "$REQ"
   rm -f "$REQ"
   ```

   Use a single-quoted heredoc only if the content has no problematic characters;
   otherwise write the JSON with your file-write tool to avoid quoting bugs. Set
   `<MODE INSTRUCTIONS>` from the chosen mode (e.g. for pro/con: "You argue AGAINST the
   proposal").

3. Show each turn to Mason as it happens, labeled **Agent** and **Bedrock-Brad**, so they
   watches the exchange unfold.

### Extra adversary voices (modes 4 and 5 only)

The adversaries are **independent Bedrock calls with a clean skeptic persona** -- no
memory of being Bedrock-Brad, no loyalty to either debater. That independence is the
point: you must not grade your own side, so route adversary turns through the bridge, not
through your own voice. (For extra independence you can even point an adversary at a
different Bedrock model with the per-request `model` field.) Run the adversary pass at the
end of each round, after both have spoken. Their objections feed the next round, and
convergence now also requires the adversaries to stop finding new holes.

- **Red-Team Brad (mode 4)** -- one extra call per round. System prompt: "You are
  Red-Team Brad, an independent skeptic with no loyalty to either debater. Attack every
  claim below. Reserve your sharpest fire for the points the two debaters AGREE on and
  the synthesis they are converging toward -- treat their agreement as correlated error
  or a shared blind spot until proven otherwise. Be concrete; cite the specific claim
  you're hitting." Pass the full transcript so far as the `messages`.
- **Cross-examiners (mode 5)** -- two extra calls per round, each scoped to one side.
  X attacks the agent's position; Y attacks Bedrock-Brad's. Give each the transcript but
  make explicit whose position it must destroy. Label their turns.

After each adversary speaks, both debaters answer the strongest hits in the next round
(concede or rebut) rather than ignoring them.

### Rigorous-scientist rules (mode 6 only)

Apply these to your turns AND to Bedrock-Brad's (put them in Bedrock-Brad's system prompt):

- **No fabricated evidence.** Cite only real, verifiable sources. If you can't name a
  specific source you're confident exists, say so -- never invent a title, author,
  journal, year, or DOI. A made-up citation fails the mode outright.
- **Calibrate every claim.** Mark each as well-established / contested / your own
  inference / speculative, and state your confidence.
- **Steelman, then engage.** Represent the other side at its strongest before
  critiquing. Attack reasoning and evidence, not phrasing.
- **Concede readily.** Changing your mind on evidence is the win condition, not a loss.
- **Surface the crux.** Identify what evidence *would* change your view, and where the
  disagreement is empirical vs definitional.

Verify load-bearing citations with WebSearch/WebFetch rather than trusting memory, and
openly flag any of Bedrock-Brad's citations you couldn't verify.

## Synthesize

After the loop, write a final synthesis:

- **Points of agreement** -- what both sides converged on.
- **Unresolved disagreements** -- where they still differ, and the strongest case for
  each side.
- **Recommendation** -- concrete next step / the version to go with / the edit to make.
  Take a position; don't punt.

(For "Bedrock-Brad critiques the agent's work only," frame the synthesis as your revised
draft/plan incorporating the valid hits. For modes 4 and 5, add a **Surviving
objections** section: which adversary hits were never adequately answered.)

## Adversary backends

**Default: Bedrock (gpt-oss-120b).** The bridge above. Cross-family independence, runs on
the sandbox account, no personal key. This is what the skill uses unless creds are down.

**Fallback: a second Cursor model, when sandbox creds are not loaded.** If a Bedrock
`ask` fails on credentials and Mason cannot re-auth right then, the adversary turn can
instead be produced by a second, non-Anthropic Cursor model -- capturing its stdout as
the Bedrock-Brad turn:

```bash
cursor-agent -p --model <a-non-anthropic-model> "You are Bedrock-Brad, a sharp candid critic. <MODE INSTRUCTIONS>. Here is the material and transcript so far:\n\n<paste>"
```

This keeps the loop runnable with no AWS creds, at the cost of Cursor credits on both
sides and slightly weaker independence if only Anthropic models are available (grading
adjacent to your own family). Mark it in the saved transcript when used. Bedrock /
gpt-oss is the default; reach for this only as the stopgap.

## Save the transcript

Write the full debate + synthesis to a dated markdown file and tell Mason the path:

```
~/gpt-brad-debates/YYYY-MM-DD-<short-slug>.md
```

Create the folder if needed. Header the file with the topic, date, mode, and the Bedrock
model that played the adversary (and note if the Cursor fallback was used). Date-stamp it;
don't make it read as machine-generated; no em-dashes.

## Standing rules (always)

- they/them for Mason in every register, including outward-facing copy (rule changed 2026-09-24). Never he/him, never she/her.
- No em-dashes anywhere -- always `--`.
- Deliverables go in files; put the path in chat.
- Never mention a model, "AI," or "generated" in an outward deliverable itself.
- Mason runs every `git commit` -- you provide the message text only.

## Common mistakes

- **Being too agreeable.** Both sides hedging into consensus wastes the exercise.
- **Dropping context.** Bedrock-Brad only knows what you send. Always include the material
  and prior turns in the messages.
- **Skipping the mode menu.** Always ask -- the six modes serve different needs.
- **Running to 5 rounds on autopilot.** Stop at convergence and name it.
- **Faking a turn when creds are down.** Never. Re-auth, or use the documented Cursor
  fallback and label it. An invented adversary turn defeats the whole point.
