AI Module Technical Specifications

Given a model name, the registry dispatches to the correct adapter automatically:

typescript // "gpt-4o" → OpenAI // "claude-sonnet-4-20250514" → Anthropic // "gemini-2.0-flash" → Google // "tripo3d-v2" → Tripo3D

57 registered providers, grouped by modality:

• Text / Reasoning (22): OpenAI, Anthropic, Google, Groq, DeepSeek, Mistral, Perplexity, xAI, Azure OpenAI, Together, Fireworks, OpenRouter, SambaNova, Ollama, HuggingFace, Moonshot, Cerebras, MiniMax, Blackbox, Novita, DashScope, Replicate
• Image generation: Stability, Ideogram, Recraft, OpenAI (DALL-E), Replicate, Fal
• 3D generation: Tripo3D, Meshy, Luma
• TTS: ElevenLabs, Cartesia, Kokoro, PlayHT, Speechmatics, Rev.ai, LMNT, Resemble, Rime, AssemblyAI, Pocket TTS, DashScope, Cohere, Voxtral, Supertonic, Novita
• STT: AssemblyAI, Deepgram, Gladia, Voxtral, Speechmatics, Rev.ai, Whisper (via OpenAI), Cohere, LlamaParse
• Video generation: Runway, Video Intelligence, Luma
• Embeddings / Reranking: Cohere, Cohere Rerank, Voyage, Jina, Nomic, Mixedbread

Every AI call generates a usage record with full context — provider, model, operation type, modality, token counts, cost breakdown, latency, tool-call count, streaming flag, and status.

Tracking is automatic — there's no manual logging call to make. When any AI operation completes, the platform records it to the usage log with tenant, user, provider, model, tokens, and cost.

Two aggregation views over the same usage log:

```typescript // Time-bucketed (hour / day / week / month), optionally filtered by provider or user async getAggregatedUsage( ctx: AeionContext, options: { startDate: Date; endDate: Date; period: "hour" | "day" | "week" | "month"; providerId?: string; userId?: string; }, ): Promise<AggregatedUsage[]>

// Grouped by a single dimension across the full date range async getUsageByDimension( ctx: AeionContext, options: { startDate: Date; endDate: Date; dimension: "provider" | "model" | "operationType" | "userId" | "source"; limit?: number; }, ): Promise<UsageByDimension[]> ```

Every usage record's status field can be success, error, or rate_limited — the last one recording when an upstream provider itself rejected a call for exceeding its rate limit. The AI module tracks and surfaces this, but doesn't enforce its own per-tenant spend cap; see the Billing module for tenant-level usage-limit enforcement.

A daily job keeps the model catalog current without a deploy:

1. For each enabled provider (OpenAI, Anthropic, Google, Cohere, etc.), it checks the provider's live model list
2. Compares that list against the cached model definitions
3. Registers any new models into the registry
4. Logs what was discovered — e.g. "discovered 3 new models from openai"

It also runs once on every boot, so newly-enabled providers get an immediate catalog pull.

Supported for auto-refresh: OpenAI, Anthropic, Google AI Studio, Cohere, Voyage AI, Mistral, Groq, DeepSeek, Together AI, Replicate, and any provider that exposes a public model-list endpoint.

Pre-call cost estimation means you can show a user an estimated cost before a call is made — no API round-trip required.

```typescript // Text — input + output tokens calculateTextCost(opts: { model, promptTokens, completionTokens?, providerId? });

// Image — flat per-image (sometimes per-resolution) calculateImageCost(opts: { model, resolution, count?, providerId? });

// Media (audio / video) — per-second or per-character calculateMediaCost(opts: { model, durationSeconds?, providerId? }); ```

Token estimation (pure JS, no API call):

```typescript function estimateTokens(text: string): number; // Rough approximation: 1 token ≈ 4 characters, regardless of language or model

// Examples: // "Hello world" (11 chars) → ~3 tokens // 1000 English words (~5,000 chars) → ~1,250 tokens ```

Current pricing (built-in, updated on every release):

• GPT-4o: $2.50/1M input, $10/1M output
• Claude 3.5 Sonnet: $3/1M input, $15/1M output
• Gemini 2.0 Flash: $0.075/1M input, $0.30/1M output
• DeepSeek R1: $0.55/1M input, $2.19/1M output

Provider configs — one row per configured provider:

• Provider ID, display name, status (active / inactive / error)
• Encrypted credentials (API key, optional custom base URL, organization / project IDs)
• Default model per modality (text, image, audio, embedding)

Usage log — one row per AI call:

• Tenant, user, provider, model, operation type, modality
• Token counts, image/audio/video counts where relevant
• Cost breakdown (input / output / media / total)
• Latency, tool-call count, streaming flag
• Status (success / error) with error code + message when applicable

Dashboard configs — one row per saved dashboard:

• Name, type (cost / usage / provider / user / custom)
• Metrics tracked, group-by dimension, date range, filters, chart type

Aeion's AI layer isn't only a gateway to other providers' models — it can also build models. The Neural Architecture Studio is a visual, drag-and-drop builder for neural network architectures.

• Drag layer nodes (linear layers, convolutions, activations, pooling) onto a canvas and wire them into a graph.
• The builder compiles the graph into an idiomatic, readable PyTorch module — including the layer declarations and a correctly-ordered forward pass — ready to hand to a data scientist or train directly.
• Device targeting (GPU / Apple Silicon / CPU) is auto-detected, so the generated module trains on whatever hardware is available.

The result is plain PyTorch a data scientist can take to a GPU cluster — so a tenant can train proprietary models on private data rather than only consuming hosted inference. A companion Neural Swarm Visualizer renders the live agent/AI layer.