Docs / How Integrated is `_AI` in Minecraft Server Government?

How Integrated is `_AI` in Minecraft Server Government?

Server civics simulation only — not real government or legal advice.

Short answer

Deeply integrated on the “brain” side, carefully separated on the “body” side.
Spigot owns truth (treasury, laws, pipeline, ballot). _AI owns deliberation (LLM agents, ethics, multi-agent sessions) and drives the server over the TCP bridge.

Split of responsibilities

Layer	Where	What it owns
Body (authoritative)	Spigot `GovernmentService.java` + `government.yml`	Pipeline phases, closed ballot, treasury, offices, charter hard-limits, enactments
Bridge	Plugin `BridgeClient` ↔ host `MinecraftSpigotBridge`	JSON `type:gov` / `gov_result`
Brain	`_AI` host + Lua	LLM congress, cabinet, court reasoning, ethics gates, RL optional
Humans	Players + owner	Fill offices; vote/sign/veto in-game; owner default `Macdaddy4sure` → president

Design rule (from docs/code): Spigot owns money/land/civics truth; _AI runs deliberation.

How tightly they plug together

1. Live command plane (always-on when bridge is up)

From _AI console:

minecraft gov status
minecraft gov bill …
minecraft gov vote chamber:senate action:…
minecraft gov sign apply
minecraft gov enact publish_budget apply
minecraft gov appoint player:Macdaddy4sure office:president apply

Same ops exist in-game as /ai gov …. Both hit the same GovernmentService.handleBridgeRequest.

2. Multi-agent legislature (optional, stronger “government brain”)

simple script execute lua_scripts/MC-Federal-Government-Agents.lua
# or
agent start mc_federal

MC-Federal-Government-Agents.lua models three branches (Senate/House, executive, judicial), can call ethics, charter review, and—if not dry-run—issues minecraft gov enact … / market commands.

Setup helpers:

simple script execute lua_scripts/MC-Government-Setup.lua
simple script execute lua_scripts/MC-Gov.lua
agent start mc_gov_setup

3. Observations into RL / bots

Plugin injects fields such as:

gov_available, gov_treasury, gov_phase, gov_office, gov_branch, senate/house/conference winners, judicial hold, etc.

So agents and training loops can see civics state without inventing server law.

4. Market linkage

Market fees can sink into the government treasury; ballot actions can halt/open markets, set fee-like tax, stimulus notices—still via closed ballot IDs only.

How “integrated” is that in practice?

Think of it as three depth levels:

Level	Integration	Needs
A. Server-only	Medium	Plugin alone: `/ai gov pipeline …` with synthetic votes if `_AI` is offline
B. Bridge control	High	`_AI` + plugin + shared token: full remote gov ops, appoint, enact
C. LLM federal sim	Highest	Level B + Lua `mc_federal` / setup scripts + optional LLM APIs

Default safety keeps C from going wild:

execute-winner: false
dry-run-default: true
Closed ballot only (no free-form ban/op/wipe laws)
High-risk items charter/ethics-checked

So _AI is fully wired to govern through the plugin, but it is not the sole government: the server can run a pipeline without LLMs, and live mutates only when you opt in with apply / execute flags.

What is not fully autonomous “AI runs the country”

No continuous always-on congress loop unless you start mc_federal / schedule scripts
Empty seats can be filled by AI agents in Lua; player offices (e.g. president Macdaddy4sure) stay human when appointed
Faction ideology (facgov) is related RP, separate from federal GovernmentService
Judicial/executive paths do not auto-ban or wipe
Without bridge connection, _AI cannot change server treasury/laws

Architecture sketch

Players / /ai gov …
        │
        ▼
┌───────────────────────┐     TCP JSON gov      ┌──────────────────────────┐
│ Spigot plugin         │ ◄──────────────────► │ _AI host                 │
│ GovernmentService     │                       │ minecraft gov …          │
│ treasury, laws,       │                       │ MC-Federal-…lua          │
│ pipeline, ballot      │                       │ ethics / LLM agents      │
└───────────────────────┘                       └──────────────────────────┘
         ▲                                                 │
         │ observation fields (gov_*)                      │
         └──────────── bots / RL / chat coach ─────────────┘

File	Role
`minecraft_spigot_plugin/.../GovernmentService.java`	Authoritative civics body
`minecraft_spigot_plugin/src/main/resources/government.yml`	Branches, ballot, charter, offices
`MinecraftSpigotBridge.cpp`	Host `minecraft gov …` + JSON bridge
`lua_scripts/MC-Federal-Government-Agents.lua`	LLM three-branch session
`lua_scripts/MC-Government-Setup.lua` / `MC-Gov.lua`	Setup console
`docs/MinecraftMarketAndGovernment.md`	Market + gov overview
`docs/ThreeBranches.md`	Pipeline detail
`docs/MinecraftServerOwner.md`	Owner identity (Macdaddy4sure)

Bottom line

_AI is a first-class co-governor of the Minecraft server: remote commands, multi-agent legislature, ethics, and setup tooling all target the same Spigot civics service.

Authority still sits on the server (config, dry-run defaults, closed ballot). Integration is strong and intentional, not a full merge where the LLM is the server.

How Integrated is _AI in Minecraft Server Government?