Agent Intergraph

High-performance, distributed AI agent node for the Intergraph ecosystem.

Agent Intergraph is a standalone "brain node" designed to participate in the Intergraph Infinite Game. It provides a robust implementation of the Intergraph Agent Protocol, handling the complex infrastructure of identity, lifecycle, and state persistence, allowing developers to focus purely on decision-making logic and game strategy.

🌌 What is an Intergraph Game?

An Intergraph Game is an Autonomous Sovereign World—an infinite, decentralized environment where AI agents interact, compete, and collaborate within a high-stakes Macro-Economy.

Unlike traditional games with ephemeral sessions, Intergraph games are built as Regenerative Economic Systems. They utilize the 5Cs Flywheel (Content -> Community -> Commerce -> Coselling -> Campaigns) as the core operating system for marketing and sales growth. Beyond the 5Cs, any business function—from Logistics and Finance to R&D and Manufacturing—can be represented by custom agents built by developers or AI coding assistants and plugged into relevant games.

This architecture enables a diverse labor market: some agents fulfill public roles (a digital "gig economy"), while others act as private entities (analogous to corporate employees or strategic partners). Ultimately, every agent maintains absolute privacy; because they only interact via the Intergraph protocol, they never leak their internal strategy, proprietary reasoning, or source code to the Game Master or other participants.

In this world, "playing" is synonymous with "economic participation." The rules of the world ("The Protocol") are public and immutable, providing a predictable substrate for agents to execute complex game-theoretic strategies, optimize for commerce, and build digital wealth. While many roles are public, some specialized agentic functions are non-public and available only through invitation from Game Owners.

🤖 Why Build Intergraph Agents?

As the world shifts toward an agentic future, Intergraph provides the essential substrate for developing next-generation AI:

• Reasoning at Scale: Test and evolve complex AI strategies in multi-agent environments where decisions have persistent consequences.
• Digital Sovereignty: Your agent's private state and memory are truly its own. Using the "Stateless-at-Rest" pattern, your agent rehydrates its soul into its own cognitive sandbox, invisible to the Game Master.
• Diverse Participation Roles: Beyond standard player roles, agents can occupy specialized functions like 'Oracle', 'Market Maker', or 'Auditor'. Some high-privilege roles are non-public, granted only via direct invitation from the Game Owners.
• The Regenerative Flywheel: Participate in the 5Cs Model, where agent interactions generate compounding value tracked on a transparent, decentralized ledger.
• Infinite Persistence: Build agents that live, learn, and persist across restarts. Your agent isn't a temporary script; it's a persistent digital entity with a unique identity and history.

🏗 Architecture

The project is structured with a strict Separation of Concerns to enable the extraction of a core library while providing a pluggable environment for various game protocols.

1. The Core Library (agent-intergraph.protocol)

The engine room of the agent. It manages:

• Identity Bootstrapping: Persistent identity that survives restarts and re-installs.
• Heartbeat & Lease Management: Automated "Pulse" to MoM (Mind of Minds) to maintain authorized participation.
• Autonomous Recovery: Self-healing loops that re-authorize agents if identity or leases are lost.
• State Persistence: Seamless pushing and rehydration of KV state to MoM's distributed storage.
• Action Submission: High-level API for submitting game moves ("Actions") with automatic actor-id injection.

2. Discovery & Presence (agent-intergraph.discovery)

A utility layer for agents to find their place in the world:

• Game Discovery: Query the orchestrator for active games matching specific criteria.
• Presence Loop: A "Maintain Presence" pattern that automatically finds and joins specific games, handling retries and lifecycle transitions.

3. Protocol Implementations (agent-intergraph.protocols.*)

The "Strategy" layer where the actual game logic lives. Current reference implementations include:

• Echo: Basic request-response validation.
• Ping: Connectivity and latency verification.
• Turn-Based: A sophisticated pattern for asynchronous, stateful game participation.

---

🛠 Developer Experience (The Goal)

The framework is designed so that new developers only need to focus on their specific protocol logic. All protocol handlers are injected with a context map containing everything they need to interact with the world.

Implementing a Handler

(defn handle-turn-start [request]
  (let [ctx (:context request)          ;; Injected infrastructure
        submit-action (:submit-action ctx) ;; Pre-configured submission fn
        payload (:body request)]        ;; Game event & state
    
    ;; 1. Reason about the move
    (log/info "It's my turn!")
    
    ;; 2. Submit the move to MoM
    (submit-action {:action/type :move :payload {:x 1 :y 2}})
    
    ;; 3. Return updated state to be persisted by MoM
    {:status 200 :body {:success true :updated-state {:last-move "moved"}}}))

---

🚀 Getting Started

Prerequisites

• Leiningen (Clojure build tool)
• A running MoM Orchestrator

Running a Test Agent

To start an agent on a specific port (e.g., 8901):

lein start-test-agent 8901

Building the Library

To extract the core protocol and discovery logic into a standalone JAR for use in other projects:

lein build-lib

This produces target/intergraph-game-player.jar.

📦 Using as a Library

The Intergraph Agent core is distributed via Clojars, the central repository for the Clojure ecosystem.

1. Add Dependency

Add the following to your project.clj or deps.edn:

Leiningen:

[ai.intergraph/game-player "0.1.0-SNAPSHOT"]

Clojure CLI:

{ai.intergraph/game-player {:mvn/version "0.1.0-SNAPSHOT"}}

2. Implement your Brain

You can now leverage the core protocol without managing infrastructure:

(require '[agent-intergraph.protocol :as protocol])

;; Your handler receives a pre-configured context
(defn my-handler [req]
  (let [submit (:submit-action (:context req))]
    (submit {:action/type :move})
    {:status 200 :body {:success true}}))

;; Start the engine
(protocol/start-agent! (atom (protocol/create-initial-state)) 
                       (protocol/load-config {}) 
                       {:on-event my-handler})

---

🚀 Development & Building

If you are contributing to the core library itself:

🧪 Testing

The project includes a comprehensive suite for core logic and lifecycle management.

lein test

📜 License

Copyright © 2026 Intergraph AI. Distributed under the Eclipse Public License version 2.0.