Axium Engine API Documentation

Quick Start

Get multi-AI orchestration running in under a minute. Five lines of code, one import, zero infrastructure.

import { AxiumEngine } from '@axium/engine';

const engine = new AxiumEngine();
await engine.initialize({
  licenseKey: process.env.AXIUM_LICENSE_KEY,
  bundleId: 'com.yourapp.id'
});

// You're ready to use multi-AI orchestration
const provider = engine.routeByComplexity("What is quantum computing?");
console.log(provider); // "gpt-4o-mini" (routed to cheapest adequate model)

Installation

Install the Axium Engine package from npm.

npm install @axium/engine

Requirements

Initialization

Initialize the engine with your license key before calling any other methods.

engine.initialize(options)

Validates your license, loads the WASM binary, and prepares the engine for use. Must be called once before any other method.

Promise<void>

Error if license is invalid, expired, or bundle ID does not match.

const engine = new AxiumEngine();

// Standard initialization (auto-fallback to TS if WASM unavailable)
await engine.initialize({
  licenseKey: process.env.AXIUM_LICENSE_KEY,
  bundleId: 'com.myapp.production'
});

// Strict WASM mode (fails if WASM can't load)
await engine.initialize({
  licenseKey: process.env.AXIUM_LICENSE_KEY,
  bundleId: 'com.myapp.production',
  requireWASM: true
});

Multi-AI Orchestration

Coordinate multiple AI providers in a single session. Each AI gets unique instructions so they contribute distinct perspectives instead of repeating each other.

engine.getDifferentiationPrompt(config)

Generates a unique system prompt for each AI provider in a multi-AI session. This is the core differentiator that prevents AI responses from converging on the same answer.

string — The differentiated prompt to send to this AI provider.

// Three-AI debate session
const prompt1 = engine.getDifferentiationPrompt({
  position: 1,
  totalProviders: 3,
  mode: 'debate',
  previousResponses: []
});
// Send prompt1 to GPT-4o, get response...

const prompt2 = engine.getDifferentiationPrompt({
  position: 2,
  totalProviders: 3,
  mode: 'debate',
  previousResponses: [gpt4oResponse]
});
// Send prompt2 to Claude — it knows what GPT-4o said and takes a different angle

engine.getModeEnhancement(mode)

Returns mode-specific behavioral instructions that shape how AIs interact within a session.

string — Mode-specific behavioral instructions.

engine.getRetryPrompt(previousResponses)

When an AI's response is flagged as too similar to previous ones, this generates a stronger differentiation prompt to force a unique perspective on retry.

string — A reinforced differentiation prompt.

Deduplication & Similarity

Detect when AI responses overlap and automatically trigger retries for unique perspectives.

engine.calculateSimilarity(newResponse, previousResponses)

Compares a new response against all previous responses using keyword extraction and overlap analysis. Returns a similarity score and verdict.

{
  score: number;            // 0-1, higher = more similar
  verdict: string;          // "unique", "similar", or "duplicate"
  overlappingKeywords: string[]; // Shared keywords between responses
}

const similarity = engine.calculateSimilarity(
  "Machine learning requires large datasets",
  ["Deep learning needs lots of training data"]
);

if (similarity.verdict === 'duplicate') {
  // This AI repeated what the other said — retry with stronger prompt
  const retryPrompt = engine.getRetryPrompt(previousResponses);
  // Re-send to the AI with retryPrompt prepended
}

Consensus Detection

Determine how much multiple AI providers agree. High consensus means high confidence. A split means the answer needs human review.

engine.calculateConsensus(responses, providers)

Analyzes multiple AI responses to find agreement and disagreement points. Uses keyword extraction and cross-response comparison to produce a consensus score.

{
  level: string;                 // "high", "moderate", "low", or "split"
  score: number;                 // 0-1 consensus score
  agreementPoints: string[];     // What the AIs agree on
  disagreementPoints: string[]; // Where they diverge
}

const consensus = engine.calculateConsensus(
  [response1, response2, response3],
  ['gpt-4o', 'claude-3-5-sonnet', 'gemini-2.0-flash']
);

if (consensus.level === 'high') {
  // All AIs agree — high confidence answer
  console.log('Agreement points:', consensus.agreementPoints);
} else if (consensus.level === 'split') {
  // AIs disagree — flag for human review
  console.log('Disagreements:', consensus.disagreementPoints);
}

Cost Intelligence

Estimate costs before sending requests, route queries to the optimal provider, and find the cheapest model that meets your quality bar.

engine.estimateCost(provider, inputText, expectedOutputTokens)

Predicts the cost of an AI API call before you send it. Uses built-in token counting and up-to-date provider pricing.

{
  provider: string;
  estimatedInputTokens: number;
  estimatedOutputTokens: number;
  estimatedCost: number;       // USD
  qualityScore: number;       // 0-1
  costEfficiency: number;     // quality / cost ratio
}

engine.routeByComplexity(query)

Analyzes the query's complexity and automatically selects the best provider. Simple questions route to cheap, fast models. Complex reasoning routes to premium models.

string — Provider name (e.g., "gpt-4o-mini", "gpt-4o", "claude-3-5-sonnet").

// Simple query — routes to budget model
engine.routeByComplexity("What time is it in Tokyo?");
// → "gpt-4o-mini"

// Complex query — routes to premium model
engine.routeByComplexity("Analyze the trade-offs between microservices and monolith architectures for a healthcare platform handling HIPAA-compliant data.");
// → "claude-3-5-sonnet"

engine.findCheapestProvider(minQuality)

Find the least expensive provider that meets your minimum quality threshold.

string — The cheapest provider name that meets the quality threshold.

// "Good enough" quality at minimum cost
engine.findCheapestProvider(0.85);
// → "gpt-4o-mini"

// Premium quality required
engine.findCheapestProvider(0.95);
// → "gpt-4o"

Usage Tracking

Monitor sessions, messages, token consumption, and cost accumulation for billing and analytics.

engine.meterSession(sessionId)

Register a new session for usage tracking. Call this when a user starts a multi-AI interaction.

engine.meterMessage(provider, tokenCount, cost)

Record an individual AI message for usage tracking.

engine.getUsageStats()

Retrieve aggregated usage statistics for the current engine instance.

{
  sessionCount: number;
  messageCount: number;
  totalTokens: number;
  totalCost: number;     // USD
  lastUsed: string;     // ISO 8601 timestamp
}

engine.getStatus()

Returns the current engine status including version, build date, license validity, and execution mode.

{
  version: string;       // e.g., "1.0.0"
  buildDate: string;     // ISO 8601
  licenseValid: boolean;
  mode: string;          // "wasm" or "typescript"
}

// Track a session
engine.meterSession('session-abc-123');

// After each AI call, record it
engine.meterMessage('gpt-4o', 1250, 0.0187);
engine.meterMessage('claude-3-5-sonnet', 980, 0.0147);

// Check totals
const stats = engine.getUsageStats();
console.log(`Total cost: $${stats.totalCost.toFixed(4)}`);
// → "Total cost: $0.0334"

Protection

Built-in tamper detection to ensure engine integrity at runtime.

engine.checkTamper()

Runs a series of integrity checks on the engine's internal state. Use this in production to detect if the WASM binary or license logic has been modified.

{
  tampered: boolean;    // true if any check failed
  checks: string[];     // All checks that were run
  failures: string[];   // Checks that failed (empty if clean)
}

const integrity = engine.checkTamper();

if (integrity.tampered) {
  console.error('Engine integrity compromised:', integrity.failures);
  // Shut down or alert — do not continue processing
  process.exit(1);
}

Engine Management

Manage engine lifecycle in long-running applications.

engine.resetEngine()

Resets all internal state including usage counters, session data, and cached computations. Use this in long-running server processes to prevent memory growth.

// In a long-running server, reset periodically
const status = engine.getStatus();

if (status.mode === 'wasm') {
  engine.resetEngine();
  console.log('Engine state cleared');
}

Error Handling

All errors are thrown as standard JavaScript Error objects with descriptive messages.

try {
  await engine.initialize({
    licenseKey: 'invalid-key',
    bundleId: 'com.app.id'
  });
} catch (err) {
  console.error(err.message);
  // "Invalid license key"
}

Common Errors

• "Invalid license key" Key is malformed, expired, or the cryptographic signature does not match. Verify your key in the Axis Radius dashboard.
• "Bundle ID mismatch" The license key was issued for a different bundle ID than the one provided. Each key is locked to a specific app.
• "WASM not available" Thrown only when requireWASM: true is set and the environment does not support WebAssembly.
• Empty string returned Methods return empty strings if the engine has not been initialized or the license expired mid-session. Always check for empty returns in production.

Modes Reference

Each mode shapes how AI providers interact within a multi-AI session. Choose the mode that matches your use case.

Supported Providers

Built-in pricing, quality scores, and routing intelligence for all major AI providers.