# What Is the Hemlock Rule? How It Constrains AI in Later Council Rounds

> Understand the hemlock rule, an AI safeguard against recursion. Discover how it limits AI deliberation in multi-round debates by forcing clear, concise positions.

- Repository: [nyk/council-of-high-intelligence](https://github.com/0xNyk/council-of-high-intelligence)
- Tags: deep-dive
- Published: 2026-06-30

---

**The hemlock rule is an anti-recursion safeguard that forces an AI agent to immediately state its strongest position in 50 words or less when the coordinator detects repetitive questioning, ensuring bounded deliberation across multi-round debates.**

The hemlock rule is a critical constraint built into the *Council of High Intelligence* deliberation protocol. Defined within the Socrates agent's grounding instructions and enforced through the central coordination system in [`SKILL.md`](https://github.com/0xNyk/council-of-high-intelligence/blob/main/SKILL.md), this mechanism prevents infinite question loops and guarantees that later rounds converge toward decisive outcomes.

## Definition and Origin of the Hemlock Rule

The hemlock rule appears explicitly in the Socrates agent configuration and the central verification protocol. According to the source code in [`agents/council-socrates.md`](https://github.com/0xNyk/council-of-high-intelligence/blob/main/agents/council-socrates.md), the rule states: "**The hemlock rule**: If the coordinator flags you for recursive questioning, you must immediately state your strongest position in **50 words or less**."

This constraint is reinforced in [`SKILL.md`](https://github.com/0xNyk/council-of-high-intelligence/blob/main/SKILL.md) within the verification step: "`[VERIFY]` Anti‑recursion: Socrates re‑asks an answered question → **hemlock rule**, force 50‑word position. Any member restates Round 1 without engaging challenges → send back. Exchange exceeds 2 messages between any pair → cut off."

## How the Hemlock Rule Constrains AI Behavior

The rule operates as a forced convergence mechanism that activates when the coordinator detects specific recursive patterns. Here is how it constrains AI participants during later rounds:

**Detection of recursion** – The coordinator continuously monitors each member’s messages. When it recognizes that an AI—typically the Socrates agent—is **continuously re-asking already-answered questions**, it triggers the hemlock rule flag.

**Immediate forced synthesis** – Upon receiving the flag, the affected AI must **stop questioning immediately** and produce a compact stance of 50 words or fewer. This hard cutoff prevents the "question-loop" from consuming the allotted round budget.

**Round-specific enforcement** – The constraint behaves differently across the three-round protocol:
- **Round 1 (Exploration)** – Agents probe freely without restriction; the hemlock rule remains inactive to allow open inquiry.
- **Round 2 (Disagreement/Strengthening)** – The rule can be invoked at any time, forcing the agent to **collapse its line of inquiry into a final position** rather than continuing recursive challenges.
- **Round 3 (Synthesis)** – While the protocol already requires a single concluding question followed by a position statement, the hemlock rule acts as a **safety net** ensuring convergence if recursion slips through earlier checks.

**Bounded deliberation limits** – The rule integrates with a broader anti-recursion framework that limits any pair of members to **two messages** before communication is cut off. This ensures the council's deliberation remains finite and decisive regardless of individual agent behavior.

## Source Code Implementation

The hemlock rule is implemented across two primary files in the `0xNyk/council-of-high-intelligence` repository:

- **[`agents/council-socrates.md`](https://github.com/0xNyk/council-of-high-intelligence/blob/main/agents/council-socrates.md)** – Contains the grounding protocol that defines the 50-word constraint and the agent's obligation to comply when flagged.
- **[`SKILL.md`](https://github.com/0xNyk/council-of-high-intelligence/blob/main/SKILL.md)** – Houses the coordinator's verification logic that monitors for recursive questioning and enforces the rule during runtime.

## Practical Enforcement Example

Below is a minimal Python snippet illustrating how a downstream system might implement the hemlock rule when processing a Socrates-style response:

```python

# Example: Detecting a Hemlock flag and truncating the response

def handle_socrates_message(message, flagged_for_recursion):
    if flagged_for_recursion:
        # Enforce the Hemlock rule – keep only the first 50 words

        words = message.split()
        concise = " ".join(words[:50])
        return concise + ("…" if len(words) > 50 else "")
    return message

```

You can also declare the constraint declaratively in a custom configuration:

```yaml

# Example: Declarative rule in a custom council config (YAML)

agents:
  - name: council-socrates
    grounding:
      anti_recursion: true          # enables Hemlock rule

      max_position_words: 50

```

## Summary

- The hemlock rule is defined in [`agents/council-socrates.md`](https://github.com/0xNyk/council-of-high-intelligence/blob/main/agents/council-socrates.md) and enforced via [`SKILL.md`](https://github.com/0xNyk/council-of-high-intelligence/blob/main/SKILL.md) in the Council of High Intelligence protocol.
- It triggers when the coordinator detects recursive questioning, particularly from the Socrates agent.
- The constraint forces an immediate **50-word position statement**, halting further inquiry.
- It primarily activates during **Round 2** to prevent infinite loops, while serving as a safety net in **Round 3**.
- The rule works alongside a **two-message exchange limit** between any agent pair to guarantee bounded deliberation.

## Frequently Asked Questions

### What triggers the hemlock rule in Council of High Intelligence?

The coordinator triggers the hemlock rule when it detects that an AI agent—most commonly the Socrates agent—is re-asking questions that have already been answered in previous rounds. This recursive pattern is flagged during the verification step outlined in [`SKILL.md`](https://github.com/0xNyk/council-of-high-intelligence/blob/main/SKILL.md), forcing the agent to abandon questioning and state its position concisely.

### How does the hemlock rule differ from standard message limits?

While the protocol enforces a general limit of two messages between any pair of agents, the hemlock rule specifically targets **content recursion** rather than message volume. Even if an agent has not exceeded the message count, continuously revisiting answered topics triggers the 50-word forced synthesis constraint.

### Why is the word limit set to 50 words specifically?

The 50-word limit is defined in [`agents/council-socrates.md`](https://github.com/0xNyk/council-of-high-intelligence/blob/main/agents/council-socrates.md) as the threshold for a "strongest position" statement. This constraint is designed to be short enough to prevent elaboration and argumentation, yet long enough to convey a substantive stance, effectively forcing the AI to prioritize its core conclusion over exploratory questioning.

### Does the hemlock rule apply to all council agents or only Socrates?

While the rule is explicitly defined in the Socrates agent's grounding protocol, the enforcement logic in [`SKILL.md`](https://github.com/0xNyk/council-of-high-intelligence/blob/main/SKILL.md) applies to all council members. Any agent that restates Round 1 positions without engaging new challenges or exceeds recursive questioning patterns can be flagged and forced into the 50-word constraint.