THIRTEEN ORACLES OF ASTRAEUM

• 

  Architecture & System Design Diagram

Inspiration

The project emerged from observing predictable AI behavior in strategy games and recognizing that multi-agent coordination with memory-based learning could create genuinely adaptive opponents. The goal was building production-grade AI agent architecture that scales beyond gaming into enterprise applications.

The player is summoned to Astraeum, a fractured celestial realm once unified under a single mythic civilization. The realm shattered into 13 dominions when divine AI cores governing each territory became self-interested and politically ambitious. These AI-driven Oracle-Wizards now rule separate domains, hoarding power and resources. Your mission is reuniting Astraeum by defeating each Oracle through strategic trials that test wisdom, combat, foresight and adaptability. Each victory binds the defeated Oracle's forces to your banner, granting mythical armies and magical abilities. Only by conquering all 13 domains can you restore the fractured world.

What it does

The system orchestrates 13 independent AI agents that generate dynamic puzzles, make tactical decisions and coordinate strategies against players. Each agent learns from interactions through vector memory, adapts behavior based on player patterns, and communicates with other agents through event streams to form alliances or modify game rules.

The game contains 13 unique puzzle challenges arranged in mandatory sequence with progressive difficulty tiers. Each Oracle domain presents distinct mechanics, spatial reasoning in ice mazes, auditory memory through musical patterns, pattern formation in terraforming grids, tactical positioning in combat scenarios and symbolic manipulation through rotating matrices. AI opponents actively interfere through lies, predictions, rule changes, and dynamic puzzle modifications. Resource management spans armies for combat power, weapons unlocking abilities, insight tokens purchasing hints, and time-extension potions. The mythological Greek setting provides thematic coherence while diverse puzzle types ensure mechanical variety. Difficulty scaling adjusts grid complexity, time pressure, and AI aggression across three tiers.

How we built it

The architecture combines FastAPI micro-services with PostgreSQL persistence, Kafka event streaming, and Redis caching. Agents execute through LangGraph orchestration calling local LLMs (Llama 3/Mistral via Ollama) with validation layers. Vector memory stores agent experiences in Weaviate for semantic retrieval. React frontend connects via WebSocket for updates with Three.js visualizations.

List of 13 AI-Agents,

Oracle of Chronos- Time & Fate

Oracle of Helios- Sun & Fire

Oracle of Nyx- Night & Shadows

Oracle of Boreas- Winter Storms

Oracle of Gaia- Earth & Growth

Oracle of Athenaia- Wisdom & Strategy

Oracle of Aresion- War & Combat

Oracle of Themis- Law & Balance

Oracle of Proteus- Illusion & Transformation

Oracle of Echo- Sound & Voice

Oracle of Selene- Moon & Dreams

Oracle of DelphiX- Prophecy & Prediction

Oracle of Typhon- Chaos

Challenges we ran into

Managing LLM hallucinations required implementing strict JSON schema validation with retry logic. Coordinating 13 agents without race conditions necessitated careful event ordering through Kafka. Preventing memory bloat in vector storage required implementing relevance scoring and periodic cleanup. Ensuring deterministic combat while maintaining agent unpredictability demanded separating calculation logic from AI decision layers.

Accomplishments that we're proud of

Successfully deployed scalable multi-agent system with sub-second response times, implemented production-ready LLM integration with validation preventing invalid outputs, created event-driven architecture handling concurrent player sessions, built comprehensive monitoring covering all system components and achieved agent learning that genuinely adapts to player behavior patterns.

What we learned

Vector databases require careful schema design for effective semantic search. LLM validation layers are critical for production reliability. Event-driven architectures need explicit ordering guarantees for state consistency. Agent memory systems must balance detail retention with query performance. Real-time WebSocket synchronization requires connection pooling and graceful degradation strategies.

What's next for THIRTEEN ORACLES OF ASTRAEUM

Implement GPU-accelerated LLM inference for reduced latency, add multiplayer coordination where agents respond to multiple concurrent players, integrate reinforcement learning for agent strategy optimization beyond supervised prompting, deploy distributed agent processing across multiple nodes for higher scalability, and create configuration interface enabling non-technical users to design custom oracle behaviors.

Built With

• agent
• agent-memory-vectors
• ai
• aiokafka
• alembic
• alembic-(migrations)
• apache-kafka
• apis
• army-unit-definitions
• asyncio
• authentication
• axios
• bash
• bcrypt
• boto3
• caddy
• containerization
• custom-agent-orchestrator
• deepseek
• devops
• docker
• docker-compose
• fastapi
• fastapi-testclient
• fastapi-websocket
• game-state-snapshots
• git
• github-actions
• grafana
• httpx
• javascript
• jose
• json
• jsonschema
• jwt-(json-web-tokens)
• kafka-event-streams
• kubernetes
• langchain
• langgraph
• llama-3
• llm
• lucide-react
• minio
• minio-(s3-compatible)
• minio-api
• mistral
• ml
• native-websocket-api
• nginx
• nomic-embed-text
• ollama
• ollama-api
• oracle-configurations-(yaml)
• passlib
• player-session-data
• postgresql-15
• postgresql-acid-transactions
• prometheus
• prometheus-client
• psycopg2
• puzzle-schemas-(json)
• pydantic
• pytest
• python-3.11
• react-18
• react-three/drei
• react-three/fiber
• redis-7
• redis-pub/sub
• redis-py
• rest-api
• reverse-proxy
• sentry
• sql
• sqlalchemy
• testing
• three.js
• typescript
• vector-embeddings-via-weaviate
• vite
• vllm
• weaviate
• weaviate-client
• web-audio-api
• websocket
• websocket-api
• yaml
• zookeeper
• zustand