Intelligent Game AI

Micro-cognitive architecture combining fast pattern recognition with LLM escalation for strategic depth.

Noesis delivers certainty-gated routing that achieves 20× cost reduction and ~150ms latency versus pure LLM approaches. Built on novel mathematics, it provides persistent learning per game-type (not per session), deterministic interfaces, and DirectML GPU acceleration — ideal for real-time competitive environments.

Use the API

20× Cost Cut

Intelligent caching

~150ms

vs 3-4s LLM

Persistent

Game-type learning

Authentication

Sign in / Sign up with Email:

Email: Password:

Or use a provider:

Your API Key for programmatic access:

How It Works

Certainty-gated routing: High certainty (≥0.65) uses fast cached patterns; low certainty (<0.40) escalates to LLM reasoning
Persistent memory: Builds per-game-type intelligence that persists across matches, enabling autonomous operation once patterns are learned
Micro-macro cognitive split: Fast pattern layer (System 1) handles 70%+ of decisions; LLM layer (System 2) handles novel strategic situations
Game-agnostic: Same architecture scales from chess to card games to open-world NPCs

Architecture Note

Noesis acts as a micro cognitive co-processor with sub-millisecond pattern operations. DirectML acceleration provides 1000× speedup over single-thread CPU for batch operations. Once a game-type cache is established, the system operates autonomously with minimal API dependencies.

Quick Start

All endpoints use the same API key as Kairos.

curl -X POST "https://entropy.occybyte.com/compute/pattern_hash" ^
  -H "X-API-Key: [YOUR_API_KEY]" ^
  -H "Content-Type: application/json" ^
  -d "{\"data\": \"chess_position_or_any_string\"}"

API Integration

Noesis endpoints provide pattern hashing, certainty scoring, and batch operations for real-time game integration. All operations maintain deterministic contracts with predictable scaling behavior and no pathological slowdowns.

Endpoints

Authenticated with X-API-Key or Authorization: Bearer <JWT>.

POST /compute/pattern_hash → Convert data to an 8D pattern vector for fingerprinting.
POST /compute/batch_demo → Batch demonstration of pattern operations.
POST /noesis/benchmark → Throughput benchmark of core operations.
POST /noesis/game_hash → Pattern signature for board/game state (e.g., FEN notation).
POST /noesis/certainty_score → Certainty score for routing decision (micro vs macro layer).
GET /noesis/health → Health status and acceleration backend info.

FAQ

Q: Is Noesis ready?
A: Not yet! Noesis requires used locally with DirectML to work, or being hosted on a Docker Container that has direct access to a medium-to-high performance GPU.

Q: Why not CUDA?
A: I tested on an RTX A5000 (comparable to an RTX 3090), and DirectML simply outperformed CUDA by a wide margin. CUDA works, but doesn’t meaningfully increase OPS.

Q: Why OPS instead of FLOPS?
A: FLOPS is great for measuring raw linear algebra throughput, but it doesn’t reflect how intelligent systems actually operate in real-time environments. OPS (operations per second) focuses on how many discrete computational actions the system can perform per second—things like state evaluations, certainty checks, and pattern resonance. For agentic AI, especially in games or adaptive systems, the critical bottleneck isn’t dense matrix math, it’s how many meaningful decisions the system can process per second. That’s why OPS gives a much more realistic picture of performance for NOESIS than FLOPS ever could.

Q: Why 8D?
A: It comes from number sense and number theory. The deeper math is abstract, but the important point is: it works and allows for predictables dimensional 'regimes' for numerical information.

Q: What's the best bet?
A: The strongest long-term path is silicon: either as a co-processor or CPU. That would make millions to nearly a billion OPS standard and accessible.

Q: What the RAM scaling?
A: It's predictable memory scaling of clean, near linear across 32 MiB up to 3.2 GiB.