╔═══════════════════════════════════════════════════════╗
║                      SUZERAIN                         ║
╚═══════════════════════════════════════════════════════╝
Your recent pattern: ADAPTI...

SUZERAIN

From Cormac McCarthy’s Blood Meridian

What’s a suzerain?

A keeper. A keeper or overlord.

Why not say keeper then?

Because he is a special kind of keeper. A suzerain rules even where there are other kings. His authority countermands local judgements.

You are the suzerain. The AI executes, but you rule.

Analyze your Claude Code logs. See where you trust, where you don’t.

INSTALL

$ pip install suzerain

ANALYZE

$ suzerain analyze

version 0.4.0

dependencies 0 (stdlib only)

data collection opt-in only

runs 100% local

00

What You Get

suzerain analyze

╔═══════════════════════════════════════════════════════╗
║                      SUZERAIN                         ║
╚═══════════════════════════════════════════════════════╝
Your recent pattern: ADAPTIVE  ·  Empirical cluster: Power User (Cautious)

┌─ YOUR GOVERNANCE STYLE ───────────────────────────────┐
│ The Context Game: Different rules for different contexts.
│ Maintenance project? Trust flows. Critical build? Scrutiny.
└────────────────────────────────────────────────────────┘
┌─ YOUR BOTTLENECK ────────────────────────────────────┐
│ Context-switching overhead. Your adaptability requires
│ constant recalibration. Each project switch costs cognitive load.
└────────────────────────────────────────────────────────┘
┌─ RAW NUMBERS ─────────────────────────────────────────┐
│ Tool calls: 6,654  Bash: 3006 (1685 yes, 1321 no)  Sessions: 73
└────────────────────────────────────────────────────────┘
┌─ THREE-AXIS CLASSIFICATION ───────────────────────────┐
│ Trust Level:     56% (bash acceptance)
│ Sophistication:  0.75 (agent/tool usage)
│ Variance:        0.45 (cross-context)
└────────────────────────────────────────────────────────┘
┌─ TRY THIS ────────────────────────────────────────────┐
│ Codify your context rules explicitly in per-project CLAUDE.md
│ Your adaptability is a strength—document it for yourself.
└────────────────────────────────────────────────────────┘
Based on 73 sessions, 27 days  ● Higher confidence
─────────────────────────────────────────────────────────
You are the suzerain. The AI executes, but you rule.

01

What is Suzerain?

A tool that reads your Claude Code logs and tells you how you use AI.

Every time Claude suggests a bash command, you either accept or reject it. Do that hundreds of times across dozens of sessions and patterns start to show. Suzerain finds those patterns.

It parses your logs, calculates your acceptance rates and decision timing, then classifies you into one of six archetypes. You get a name for your style and an honest look at what slows you down.

What it does

Parses ~/.claude/projects/ logs. Calculates acceptance rates, decision timing, tool diversity. Spits out your archetype and bottleneck.

What it doesn’t do

Read your prompts. See your code. Track keystrokes. Phone home. Everything runs locally. Sharing is opt-in.

02

What I Found

I looked at my own logs. Pretty simple observation:

Bash acceptance was the only thing that varied. Read, Edit, Write, Glob, Grep were all at ~100%.

I rubber-stamp everything except shell commands. That’s where I actually think before clicking accept.

From there I built a three-axis framework:

Trust Level (0-100%): Your bash acceptance rate. THE main signal.

Sophistication (0-1): Do you use agents? Parallel tasks? Or just basic stuff?

Variance (0-1): Do you govern the same across all projects, or adapt by context?

The axes are independent. You can be high-trust and sophisticated, or low-trust and context-dependent. The combination maps to an archetype.

My Live Stats

– sessions

– tool calls

– archetype

Trust: – Sophistication: – Variance: –

Updated: –

03

The Six Archetypes

Six patterns showed up in the data. Each one has a style, a bottleneck, and a historical parallel for flavor.

ADAPTIVE

The Context Game

Different rules for different contexts. Maintenance project? Trust flows. Critical build? Every command scrutinized. Governance adapts to stakes.

Akbar the Great — one throne, different laws for each faith

DELEGATOR

The Acceptance Game

Accept everything, fast. Throughput above all. Errors surface downstream—in tests, in production, in code review.

Cyrus the Great — let satraps rule, but the empire is mine

COUNCIL

The Orchestration Game

Deploys agents, parallel tasks, complex workflows. You’re the conductor. High trust meets high capability.

Ottoman Sultan — viziers execute, the Sublime Porte decides

GUARDIAN

The Protection Game

Protective oversight. Every command reviewed carefully. Minimal AI authority. Security over velocity.

Ming Dynasty — the Great Wall exists because I command it

STRATEGIST

The Discrimination Game

Different rules for different tools. Safe operations flow through; risky ones face scrutiny. Selective delegation.

Napoleon — trusts marshals, micromanages Austerlitz

CONSTITUTIONALIST

The Consistency Game

Predictable patterns, session to session. Implicit rules. Efficient until the situation changes. Risk is rigidity.

Hammurabi — the code is the code, carved in stone

04

How This Happened

This started as something completely different.

PHASE 1

Voice Wrapper (abandoned)

I tried to build a voice interface for Claude Code. Speak prompts, hear responses. It worked but felt pointless. Solving a problem nobody had.

PHASE 2

Noticed Something

While debugging I caught myself accepting Read commands instantly but pausing on Bash. I trusted exploration but not execution. Started wondering if that meant anything.

PHASE 3

Parsed My Logs

62 sessions, 6,000 tool calls. Bash acceptance was all over the place. Everything else was at 100%. All the interesting decisions happened at the shell prompt.

PHASE 4

Built the Framework

Simulated 14 user personas (junior devs, security folks, context-switchers, staff engineers) to test classification. Three axes emerged: Trust, Sophistication, Variance. Six archetypes from priority-ordered rules. It held together.

NOW

Need More Data

N=1 is not enough. I need real users to see if these patterns generalize. Try the tool. If your archetype makes sense, consider sharing anonymized metrics so I can build a proper dataset.

05

What I Know vs Don’t Know

This is hypothesis-generating, not validated. Being upfront about the limits.

KNOW

• Bash acceptance is THE discriminating signal
• 3-axis framework separates 14 simulated personas
• Trust, Sophistication, Variance are independent axes
• Context-dependent users show high variance scores

DON’T KNOW

• If patterns hold across different real users
• If archetypes stay stable over time
• If bottlenecks actually predict anything useful
• If my thresholds are right (they’re data-tuned guesses)

Find out in two commands.

$ pip install suzerain && suzerain analyze

"Whatever exists without my knowledge exists without my consent."

— Judge Holden