---
name: query_council
description: Ask up to four leading AI models (ChatGPT, Claude, Gemini, Grok) the same question and get one consensus answer plus an agreement analysis showing what the models agree on and exactly where they split. Use when verification, a second opinion, or multi-perspective analysis would catch blind spots that a single model misses.
version: 2.2.0
---

# Skill: query_council

## When to use

Invoke this skill when:

- You want a second opinion on a high-stakes decision.
- A single model's answer could be biased, wrong, or incomplete.
- The question rewards multiple perspectives (architecture trade-offs, strategy, due diligence, code review, research synthesis).
- You want cross-model agreement as a confidence signal.

Do not invoke it for:

- Simple lookups or deterministic math.
- Latency-sensitive requests (Synero runs several models in parallel and then reconciles them, so it is slower than one model). For a quick answer from one model, pass `preset: "solo"`.
- Tasks where any one model is clearly sufficient.

## How to call

**Endpoint.** POST https://synero.ai/api/query

**Auth.** Bearer token. Keys look like `sk_live_...` and are issued at https://synero.ai/app/api-keys. See https://synero.ai/.well-known/oauth-protected-resource for RFC 9728 metadata.

**Recommended body.**

    {
      "prompt": "Is Rust or Go better for a low-latency web service?",
      "format": "json",
      "preset": "council"
    }

`preset` is `solo`, `duel`, `council` (up to four models, balanced for speed), `deep` (up to four flagship models) or `auto` (Synero picks one of those, and the models, for the question). Or name the models yourself with `models`: 1 to 4 model ids, at most one per provider (see https://synero.ai/openapi.json for ids).

**Response shape (`format: "json"`).**

    {
      "queryId": "...",
      "synthesis": "The consensus answer...",
      "consensus": {
        "score": 74,
        "unanimous": ["..."],
        "contested": [{ "topic": "...", "positions": [{ "slot": "maverick", "stance": "..." }] }],
        "dissenter": "maverick"
      },
      "advisors": {
        "architect": { "response": "...", "model": "gpt-5.6-terra", "latencyMs": 0 },
        "philosopher": { "response": "...", "model": "claude-sonnet-5-5", "latencyMs": 0 }
      }
    }

`synthesis` is the consensus answer and `consensus` shows where the models agree and split. Slots are fixed by provider (openai architect, anthropic philosopher, google explorer, xai maverick); read `model` to tell answers apart. `consensus` is null for a single model or when grading fails.

**Raw mode.** Pass `"synthesis": false` to skip the server-side consensus: you get each model's answer and reconcile them yourself (state what two or more models reached independently, name genuine disagreements rather than averaging them, note anything only one model caught, then answer with confidence weighted by agreement). Cheaper and faster; the `consensus` analysis is still returned. If a requested synthesis fails (for example, the synthesizer refuses the prompt), `synthesis` is null and `synthesisError` gives the reason: reconcile the answers yourself.

Omit `format` to receive an SSE stream (events: `council-meta`, `advisor`, `advisor-complete`, `advisor-error`, `synthesis-start`, `synthesis`, `synthesis-complete`, `consensus`, `complete`, `error`; `consensus` usually arrives during synthesis but may arrive after `complete`, so read until the stream closes. JSON responses wait for it, about 4s, up to 20s, and return null when grading fails). A failed synthesis arrives as `synthesis-complete` with an `error` field, not as a fatal `error` event.

## Useful optional fields

- `models` / `preset`: who answers (above). Without either, the legacy auto-sized council runs.
- `web_search` (boolean): let each model search the web first. Omit it and search turns on automatically for time-sensitive questions (news, prices, "latest", this year, a URL), reported as `webSearchAuto`; `false` skips it. Slower and adds search fees.
- `parent_query_id` (string): the `queryId` of an earlier result of yours. The server rebuilds that conversation so you can ask a follow-up with context. `thread_id` groups queries in the history.
- `private` (boolean): do not save the query (no `queryId`, so no follow-up).
- `template` (string): preconfigured council for a task. Useful slugs: `code-review`, `architecture-decision`, `debugging`, `deep-research`, `due-diligence`, `strategy-brief`, `devils-advocate`.
- `context` (array): attach documents or images. `{ name, content, type? }` per item. `content` must be the actual text inlined; the API cannot read file paths or URLs. Text: max 50k chars per item, 100k total. Images: type "image", content is a base64 data URL (png/jpeg/webp/gif, max 3, 5MB each).
- `config`: legacy four-persona council overrides (`councilTier`, `advisorModels`, `synthesizerModel`). Ignored when `models` or `preset` is sent.

## Latency

A council with consensus typically finishes in under a minute; `deep` and `web_search` take longer, and `synthesis: false` removes the second sequential model call. Via the API/MCP path an explicit `high` tier runs as `medium` (reported as `cappedFrom`) and a stuck model is cut off after 10 minutes. A `format: "json"` run still going after about 60s answers 200 and sends newlines (valid leading JSON whitespace) until the object; a failure after that arrives in the body as `{ error, code }`, so check for `code`. Prefer SSE for `deep` or `web_search` runs. The remote MCP endpoint streams progress notifications (one per model completion) for clients that honor them; a run still going after about two minutes returns `status: "running"` and a `job_id`, and keeps running: collect it with the free `get_council_result` tool rather than calling `query_council` again.

## Rate limits and errors

- 60 requests per minute per API key (counted per server instance, so a guide rather than an exact quota).
- Headers on successful API-key responses and on 429: `X-RateLimit-Limit`, `X-RateLimit-Remaining`, `X-RateLimit-Reset`; 429 adds `Retry-After`.
- Errors are JSON `{ error, code, doc_url }`: 400 invalid request, 401 invalid key, 402 billing, 404 `parent_not_found`, 429 rate limited.

## MCP transport

Agents on MCP can install this skill as an MCP server:

- Remote (OAuth or API key bearer): https://synero.ai/api/mcp
- Protected Resource Metadata (RFC 9728) for /api/mcp: https://synero.ai/.well-known/oauth-protected-resource/api/mcp
- Local package: `@syneroai/mcp` (run via `npx -y @syneroai/mcp`, env `SYNERO_API_KEY=sk_live_...`); a thin proxy to the remote endpoint, so the tool is identical.
- Server card: https://synero.ai/.well-known/mcp-server
- Tool exposed: `query_council` with `models` (enum of model ids), `preset`, `web_search`, `synthesis`, `detail`, `parent_query_id`, `thread_id`, `private`, `context`, `template`.
- `synthesis` (MCP, default true): the tool returns the consensus answer plus the agreement analysis (score, what every model agreed on, where they split and which model said what), labeled by model name, and the result carries `queryId` and a link. Pass `false` for the cheaper raw mode (every answer plus instructions to reconcile them yourself; the agreement analysis is still included).
- `detail` (MCP): `"synthesis"` (default) keeps your context small; `"full"` adds each model's complete answer.
- Results include `structuredContent` matching the tool's `outputSchema`.

## Links

- OpenAPI: https://synero.ai/openapi.json
- Agent guide: https://synero.ai/agents.md
- Full docs: https://synero.ai/llms-full.txt
