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

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, 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, 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 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 – Contains the grounding protocol that defines the 50-word constraint and the agent's obligation to comply when flagged.
• 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:

# 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:

# 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 and enforced via 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, 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 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 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.

{
  "mcpServers": {
    "instagit": {
      "command": "npx",
      "args": ["-y", "instagit@latest"]
    }
  }
}