synchromy-skills

Portable AI agent skills from Synchromy, starting with council: a multi-model AI council for hard technical and strategic decisions.

Use it when one model's answer is not enough: architecture tradeoffs, agentic workflow design, vendor choices, product scope, launch calls, security-sensitive changes, and any decision where hidden cost or goal drift matters.

A skill is a self-contained capability an agent can load: a SKILL.md describing when and how to use it, plus any scripts it needs. The skills here are portable. They read their configuration from flags and environment variables, they do not assume a particular agent runtime, and they write nothing to a private knowledge base.

Keywords this repo is intentionally useful for: AI council, multi-model council, Claude Code skill, Codex skill, agent skill, adversarial reasoning, LLM debate, model ensemble, AI decision-making, agent governance, and decision packet.

Skills

Skill What it does
council Convene a multi-model adversarial council (Skeptic, Builder, Strategist, Operator across different model families) to resolve a contentious decision, then emit one markdown decision packet with a recommendation, named dissents, open questions, and the full transcript appendix.

More will land here over time. Each skill is independent; take the one you want.

Why council is different

Most "ask the council" prompts simply send the same question to several models and summarize the answers. That can be useful, but it often produces a polite average.

council is built for decisions where averaging is the problem:

  • Named adversarial roles: Skeptic, Builder, Strategist, and Operator each argue from a different bias, so hidden cost, next action, goal-fit, and three-month maintenance pain are all represented.
  • Fresh-context first round: members produce independent positions before seeing each other's arguments.
  • Cross-rebuttal before synthesis: the second round tests disagreement instead of jumping straight to consensus.
  • Decision packet output: the chair produces a practical recommendation, named dissents, open questions, and an appendix you can audit later.
  • Portable by default: standard-library Python, no private Synchromy runtime, no database dependency, no hidden knowledge-base writes.
  • Model-family diversity: Anthropic, OpenAI/Codex, Moonshot/Kimi, Z.ai/GLM, and xAI/Grok can be assigned by tier or role when provisioned.
  • Cost-aware dry run: see model assignment, credential availability, warnings, and estimated cost before any provider call happens.

The goal is not "more models means more truth." The goal is to make disagreement legible before you commit.

Good use cases

  • Should we rewrite this subsystem or patch it and defer?
  • Which model/provider should own this agent workflow?
  • Is this product scope actually on-axis for the business goal?
  • Should we adopt this vendor, framework, database, or deployment substrate?
  • What is the smallest reversible test before a larger build?
  • What will this decision make painful three months from now?

Bad use cases: factual lookups, simple code edits, rubber-stamp approvals, and anything where you already know the answer.

Quickstart: council

git clone https://github.com/Synchromy/synchromy-skills.git
cd synchromy-skills

# See the plan and cost without spending anything or contacting any provider:
python3 skills/council/council.py \
  --goal "ship the mobile app before Q3" \
  --topic "rewrite the sync layer now, or patch it and defer" \
  --dry-run --stdout

The dry run prints the model assignment, an estimated cost, which model families it found credentials for, and any warnings. When you are ready, drop --dry-run to run the debate and write a decision packet to ./council-packets/.

Full documentation, including roles, cost tiers, and backends, is in skills/council/SKILL.md.

Example output shape

The generated packet is designed for a decision owner, not for model theater:

# Patch the sync layer now, defer the rewrite

## TL;DR
Ship the smallest patch that stabilizes sync before Q3, but do not start the
rewrite until usage data proves the current architecture is blocking growth.

## Recommendation
- Patch the failure mode this week.
- Add logging around conflict resolution.
- Set a kill criterion: if sync incidents exceed the agreed threshold for two
  weeks, reopen the rewrite decision with fresh evidence.

## Dissents (named)
- **Builder dissents on waiting for the rewrite:** ...
- **Operator partial-dissents on the patch:** ...

## Open questions for the decision owner
- What incident threshold justifies a rewrite?

Configuration and keys

Skills read secrets at runtime and never write them to disk or print them.

council prefers the 1Password CLI: set COUNCIL_OP_VAULT to a vault holding your provider keys and it resolves each one with op read at dispatch. On a machine without op, set the provider environment variables instead (see .env.example) and pass --keys env.

The GPT seat routes through the Codex CLI rather than a raw OpenAI key, so install and log in to Codex if you want a GPT voice in the council.

council's value is model-family diversity. The diversity you get is the diversity you provision: if only one family's credentials are present, it runs a single-family panel and says so rather than failing.

Requirements

  • Python 3.10 or newer (standard library only; no third-party Python dependencies).
  • Provider credentials for whichever model families you want in the council.
  • Optional: the 1Password CLI (op) for key hygiene, and the Codex CLI for the GPT seat.

Suggested GitHub topics

If you fork or publish a variant, these topics make the repo easier to discover:

ai-agents, agent-skills, claude-code, codex, llm, multi-model, ai-council, agent-governance, adversarial-reasoning, decision-making, python, open-source.

Security

Skills here follow a simple rule: credentials come from the environment or a secrets manager at runtime, are never persisted, and are never logged. See SECURITY.md. If you find a security issue, please open a private report rather than a public issue.

License

MIT. Use it, fork it, ship it.