Updating EigenAI overview

docs/eigenai/concepts/eigenai-overview.md

@@ -17,30 +17,60 @@ To integrate deTERMinal token credit with your client, refer to the [Grant API I
 For more tokens or different models, you can [contact us here](https://ein6l.share.hsforms.com/2L1WUjhJWSLyk72IRfAhqHQ).
 :::
 
-## Overview
-Build verifiable applications leveraging LLM inference without wondering if the same LLM call might produce different results 
+## What is EigenAI? 
+
+EigenAI is a deterministic, verifiable LLM inference service that provides an OpenAI-compatible API for executing open source LLMs.
+Unlike traditional AI services where you trust the provider's outputs, EigenAI enables cryptographic verification where inference
+is executed using the specified model and input, and the output results are untampered.
+
+:::note
+- OpenAI-compatible refers to the [messages-based Chat Completions API](https://platform.openai.com/docs/api-reference/chat/create).
+- Deterministic behavior refers to providing one request (prompt, seed/parameters) to the EigenAI API multiple times and receiving the same output bit-by-bit every time. The EigenAI inference stack is designed with this determinism guarantee. 
+- Deterministic behavior requires not caching the results. Safety-critical systems cannot be vulnerable to potential cache misses.
+:::
+
+## Why build with EigenAI? 
+
+1. Build verifiable applications leveraging LLM inference without wondering if the same LLM request might produce different results
 on different runs, or whether your prompts, models, or responses are modified in any way. EigenAI offers:
 
-* [Deterministic execution of EigenAI API requests.](deterministic-execution.md)
-* [Drop-in compatibility with the OpenAI API.](drop-in-compatibility.md)
+    * [Deterministic execution of EigenAI API requests.](deterministic-execution.md)
+    * [Drop-in compatibility with the OpenAI API.](drop-in-compatibility.md)
+
+2. EigenAI provides the rails to instill trust for downstream stakeholders (such as users) that an AI output was executed 
+as expected, and verifiably executed, improving confidence in automated and agentic workflows.
+
+## How EigenAI works? 
+
+EigenAI delivers verifiable LLM inference by making GPU execution a deterministic pipeline.
+
+### Deterministic inference
+
+EigenAI controls GPU execution and removes typical non-deterministic behavior found in kernel race conditions and opportunistic memory reuse. The overhead for this control remains negligible and retains practical inference performance (benchmarks will be included in the upcoming technical report).
+
+### Isolated per-request execution
+
+Each query runs in its own clean environment. The KV cache is reset, the full context is loaded, and tokens are generated sequentially with no batching or shared GPU state. This ensures that no other workload can influence the execution path or final output.
+
+### Seed-controlled sampling
+
+Randomness is governed through strict seed management. Users can provide a seed or rely on fixed defaults. This makes every result reproducible and enables users, or third parties, to re-run the exact same request to confirm correctness.
+
+:::note
+If different outputs for the same prompt are required, you can achieve this by setting different seeds across different requests of the same prompt, while retaining the option of deterministically replaying any of the requests with its respective seed.
+:::
+
+### Model and hardware integrity
 
-## Use Cases
+EigenAI provides a consistent, verifiable execution stack. Model weights, quantization levels, and GPU types are fixed. Only H100 GPUs are used, with ECC memory enabled, providing stable, integrity-preserving computation.
 
-Builders are leveraging EigenAI to build applications such as:
-- **Prediction Market Agents**: Build agents who can interpret real world events, news, etc and place bets or dispute market settlements.
-- **Trading Agents**: Build agents who can reason through financial data with consistent quality of thinking (no need to worry if models are quantized or not in production) while you ensure they process all of the information they're given (unmodified prompts) and that agents actually use the unmodified responses. You can also ensure they reliably make the same trading decision if prompted about the same data multiple times (via EigenAI's determinism).
-- **Verifiable AI Games**: Build games with AI characters or AI governance, where you can prove to your users that their interactions with the AI aren't being gamed.
-- **Verifiable AI Judges**: Whether it's contests / games, admissions committees, or prediction market settlements, AI can be used to verifiably judge entries / submissions.
+## Verifiability Roadmap
 
-<img src="/img/eigenai-use-cases.jpg" alt="EigenAI Use Cases"/>
+EigenAI’s deterministic execution makes verification possible through deterministic re-execution. As we move through mainnet alpha into general availability, the verification pathways expand.
 
-## Get started 
+### Self-verification (Mainnet Alpha)
+EigenAI will open source its inference stack. Anyone with access to commodity GPUs (H100s) can re-run a request locally using the same model, inputs, and seed, and confirm that the output matches bit-for-bit.
 
-A few key points:
+### Third-party verification (GA Target)
+A separate verification API will allow independent operators to re-execute requests and return attestations. Applications can use this to spot-check results or provide external proof that an inference was executed correctly.
 
-- By OpenAI compliancy we specifically mean the messages-based Chat Completions API: https://platform.openai.com/docs/api-reference/chat/create
-- By “deterministic” we specifically mean that one request (prompt, parameters, etc) provided to the API multiple times will produce the **same output bit-by-bit**, compared to the potentially varying responses one would typically get if calling an OpenAI, Anthropic, etc endpoint as they do not guarantee deterministic behavior. We will be releasing more details shortly on how EigenAI achieves this across the stack.
-- On wanting non-determinism:
-    - You can still introduce non-determinism in your application if you want. By setting a different seed for requests but otherwise keeping the request the same, the API will produce a different output.
-- On verification: As part of EigenAI’s mainnet alpha release, the code will be open sourced shortly after. Anyone with access to commodity GPUs will be able to leverage the determinism of EigenAI's software to re-execute any requests and verify the responses given to them by EigenAI.
-    - As we go towards general availability, we will stand up another API that can be used for this verification flow.

docs/eigenai/concepts/use-cases.md

@@ -0,0 +1,12 @@
+---
+title: Use Cases
+sidebar_position: 4
+---
+
+Builders are leveraging EigenAI to build applications such as:
+- **Prediction Market Agents**: Build agents who can interpret real world events, news, etc and place bets or dispute market settlements.
+- **Trading Agents**: Build agents who can reason through financial data with consistent quality of thinking (no need to worry if models are quantized or not in production) while you ensure they process all of the information they're given (unmodified prompts) and that agents actually use the unmodified responses. You can also ensure they reliably make the same trading decision if prompted about the same data multiple times (via EigenAI's determinism).
+- **Verifiable AI Games**: Build games with AI characters or AI governance, where you can prove to your users that their interactions with the AI aren't being gamed.
+- **Verifiable AI Judges**: Whether it's contests / games, admissions committees, or prediction market settlements, AI can be used to verifiably judge entries / submissions.
+
+<img src="/img/eigenai-use-cases.jpg" alt="EigenAI Use Cases"/>