# Agentics - Complete Platform Documentation

> Agentics is a comprehensive AI infrastructure company providing enterprise-grade APIs, tools, and services for voice processing, language model inference, embeddings, networking, and real-time data. The platform delivers a complete end-to-end ecosystem of modular, interconnected services that developers and businesses can integrate to build AI-powered applications.

**Base URL:** `https://api.agentics.co.za`
**Website:** `https://agentics.co.za`
**Version:** 1.0.0

---

## Table of Contents

1. [Authentication](#authentication)
2. [Text Generation & Chat](#text-generation--chat)
3. [Image Generation](#image-generation)
4. [Audio - TTS, STT, Live Transcription](#audio--tts-stt-live-transcription)
5. [Realtime Voice Agent](#realtime-voice-agent)
6. [Orb - Embeddable Voice Widget](#orb--embeddable-voice-widget)
7. [Agent System](#agent-system)
8. [Embeddings & Vector Search](#embeddings--vector-search)
9. [WebGrep - Web Search & Extraction](#webgrep--web-search--extraction)
10. [VPN Proxy Service](#vpn-proxy-service)
11. [Payments & Subscriptions](#payments--subscriptions)
12. [Conversations & Memory](#conversations--memory)
13. [MCP - Model Context Protocol](#mcp--model-context-protocol)
14. [CDN & Widgets](#cdn--widgets)
15. [SDKs](#sdks)
16. [Products](#products)
17. [Website Pages](#website-pages)
18. [Technology Stack](#technology-stack)
19. [Contact](#contact)

---

## Authentication

All authenticated endpoints require a valid API key or JWT token passed via the `Authorization` header.

```
Authorization: Bearer YOUR_API_KEY
```

API keys are prefixed with `ag_` and are SHA256 hashed for storage. JWT access tokens expire after 7 days; refresh tokens expire after 30 days.

### POST /v1/auth/register

Register a new user account.

**Request Body:**
```json
{
  "email": "user@example.com",
  "password": "securepassword123",
  "username": "johndoe"
}
```

**Response:**
```json
{
  "token": "eyJhbGciOiJIUzI1NiIs...",
  "refreshToken": "eyJhbGciOiJIUzI1NiIs...",
  "user": {
    "id": "507f1f77bcf86cd799439011",
    "email": "user@example.com",
    "username": "johndoe"
  }
}
```

### POST /v1/auth/login

Authenticate with email and password.

**Request Body:**
```json
{
  "email": "user@example.com",
  "password": "securepassword123"
}
```

**Response:**
```json
{
  "token": "eyJhbGciOiJIUzI1NiIs...",
  "refreshToken": "eyJhbGciOiJIUzI1NiIs...",
  "expiresIn": 86400
}
```

### POST /v1/auth/hardware-auth

Device-based authentication using a hardware identifier.

**Request Body:**
```json
{
  "hardwareId": "ABC123-DEF456-GHI789",
  "application": "AgentX"
}
```

### POST /v1/auth/refresh

Exchange a refresh token for a new access token.

**Request Body:**
```json
{
  "refreshToken": "eyJhbGciOiJIUzI1NiIs..."
}
```

### GET /v1/auth/profile

Retrieve the authenticated user's profile. Requires bearer token.

**Response:**
```json
{
  "id": "507f1f77bcf86cd799439011",
  "email": "user@example.com",
  "username": "johndoe",
  "subscriptionTier": "pro",
  "tokensUsed": 15000,
  "tokensLimit": 100000
}
```

### POST /v1/auth/api-keys

Generate a new API key. Requires bearer token.

**Request Body:**
```json
{
  "name": "Production Key"
}
```

**Response:**
```json
{
  "id": "507f1f77bcf86cd799439012",
  "key": "ag_live_xxxxxxxxxxxxxxxxxxxx",
  "name": "Production Key",
  "createdAt": "2024-01-15T10:30:00Z"
}
```

### GET /v1/auth/api-keys

List all API keys for the authenticated user.

---

## Text Generation & Chat

### GET /v1/models

List all available text generation models. No authentication required.

**Available Models:**

| Model | Description |
|-------|-------------|
| ALM | Agentics Language Model - Flagship frontier model |
| ALM-NRN | Flagship model with neuroplastic persistent memory |
| NRNAgent | Auto-routed model with neuroplastic persistent memory |
| Neo | Unrestricted frontier reasoning model |
| Nitro | Deep reasoning and analysis model |
| PolarisNRN | Versatile model with neuroplastic persistent memory |
| Pollaris | Versatile general-purpose model |
| Sigma | Flagship frontier model (ALM alias) |
| SigmaNRN | Flagship model with neuroplastic persistent memory |
| Syntactic | Precision code generation model |
| Ultra | Maximum capability frontier model |
| auto | Automatic model routing via Agentics gateway |

**Model Aliases:** default→ALM, flagship→ALM, fast→ALM, code→ALM, coder→ALM, pro→ALM, reason→ALM, research→ALM, think→ALM, vision→ALM, memory→NRNAgent, nrn→NRNAgent, sigma→Sigma, neo→Neo, nitro→Nitro, ultra→Ultra, pollaris→Pollaris, syntactic→Syntactic, gateway→auto

### POST /v1/generate

Generate text from a prompt. Supports streaming. Requires bearer token.

**Request Body:**
```json
{
  "prompt": "Explain quantum computing in simple terms",
  "model": "Sigma",
  "maxTokens": 500,
  "temperature": 0.7,
  "systemPrompt": "You are a helpful assistant."
}
```

**Response:**
```json
{
  "text": "Quantum computing is a type of computation that...",
  "model": "Sigma",
  "tokensUsed": 150,
  "finishReason": "stop"
}
```

### POST /v1/chat/completions

OpenAI-compatible chat completions endpoint. Requires bearer token.

**Request Body:**
```json
{
  "messages": [
    {"role": "system", "content": "You are a helpful assistant."},
    {"role": "user", "content": "Hello!"}
  ],
  "model": "Sigma",
  "max_tokens": 500,
  "temperature": 0.7,
  "stream": false
}
```

**Response:**
```json
{
  "id": "chatcmpl-abc123",
  "object": "chat.completion",
  "created": 1705320000,
  "model": "Sigma",
  "choices": [{
    "index": 0,
    "message": {"role": "assistant", "content": "Hello! How can I help you today?"},
    "finish_reason": "stop"
  }],
  "usage": {
    "prompt_tokens": 20,
    "completion_tokens": 10,
    "total_tokens": 30
  }
}
```

---

## Image Generation

### GET /v1/images/models

List all available image generation models. No authentication required.

**25 Image Models:**

| Model | Category | Description |
|-------|----------|-------------|
| Anime | Anime | Anime style generation |
| AnimeReal | Anime | Realistic anime style |
| Cinematic | Artistic | Movie-quality cinematic images |
| Epic | Artistic | Epic cinematic imagery |
| Fantasy | Artistic | Fantasy art generation |
| Flux | Fast | Fast high-quality image generation |
| Ghibli | Anime | Studio Ghibli style |
| Juggernaut | General | Powerful versatile model |
| LowPoly | 3D | Low poly 3D style |
| Medieval | Historical | Medieval art style |
| Pencil | Stylized | Pencil sketch style |
| Photo | Photorealistic | Professional photography style |
| Pixel | Stylized | Pixel art generation |
| Playground | General | Creative playground model |
| Portrait | Photorealistic | Realistic portrait generation |
| Pro | General | Enhanced SDXL model |
| Professional | Business | Professional business imagery |
| Realism | Photorealistic | Photorealistic image generation |
| Retro | Anime | Retro anime aesthetic |
| SDXL | General | Stable Diffusion XL base model |
| Stock | Photorealistic | Stock photo quality images |
| ThreeD | 3D | 3D rendered imagery |
| Turbo | Fast | Ultra-fast image generation |
| VanGogh | Stylized | Van Gogh painting style |
| Watercolor | Stylized | Watercolor painting style |

### POST /v1/images/generations

Generate images from text prompts. Requires bearer token.

**Request Body:**
```json
{
  "prompt": "A serene mountain landscape at sunset with vibrant colors",
  "model": "Juggernaut",
  "width": 1024,
  "height": 1024,
  "n": 1,
  "negative_prompt": "blurry, low quality",
  "ratio": "1:1",
  "format": "url"
}
```

**Parameters:**
- `prompt` (string, required) - Text description of the image
- `model` (string, default: "Flux") - Image model to use
- `width` (integer, default: 1024) - Image width in pixels
- `height` (integer, default: 1024) - Image height in pixels
- `n` (integer, default: 1) - Number of images to generate
- `negative_prompt` (string, optional) - Things to avoid
- `ratio` (string, default: "1:1") - Aspect ratio (1:1, 16:9, 9:16, etc.)
- `format` (string, default: "url") - Output format: "url" or "b64_json"

---

## Audio - TTS, STT, Live Transcription

### GET /v1/audio/voices

List available TTS voices. No authentication required.

**Voices:** male1, male2, female1, female2, justine

### POST /v1/audio/tts

Text-to-speech synthesis using local ONNX models. Requires bearer token.

**Request Body:**
```json
{
  "text": "Hello, welcome to Agentics!",
  "voice": "justine",
  "speed": 1.0,
  "quality": 20,
  "outputBase64": false
}
```

**Parameters:**
- `text` (string, required) - Text to convert to speech
- `voice` (string, default: "female2") - Voice to use
- `speed` (number, default: 1.2) - Speech speed multiplier
- `quality` (integer, default: 20) - Audio quality (1-100)
- `outputBase64` (boolean, default: false) - Return base64 encoded audio

**Response:** WAV audio file directly, or JSON with base64 if outputBase64=true

### POST /v1/audio/stt

Speech-to-text transcription. Requires bearer token.

**Request:** multipart/form-data with `file` (audio file) and optional `language` (string).

**Response:**
```json
{
  "text": "Hello, this is a test transcription.",
  "language": "en",
  "durationMs": 2500
}
```

### GET /v1/audio/live/status

Check live transcription service status.

### WS /v1/audio/live/ws

WebSocket for real-time audio transcription. Authenticate via query param `token`.

**Query Parameters:**
- `token` (string, required) - Bearer token
- `language` (string, default: "en") - Language code

**Send:** Audio data as binary or JSON messages
**Receive:** Transcription events:
```json
{
  "type": "transcription",
  "text": "Hello world",
  "isFinal": true,
  "confidence": 0.95
}
```

---

## Realtime Voice Agent

Full real-time conversational AI with integrated VAD, EOT detection, STT (Groq Whisper), TTS (neural voices), and tool calling. Similar to OpenAI Realtime API and Google Gemini Live.

### GET /v1/realtime/status

Check capabilities and status. Returns available voices, features, audio format specs, and query parameters.

**Features:** VAD (Silero), EOT (End-of-Turn), STT (Groq Whisper large-v3), TTS (Neural), Inference (Multi-model LLM), Tools (Function calling)

### WS /v1/realtime

WebSocket for real-time voice AI agent.

**Query Parameters:**
- `model` (string, default: "Odin") - LLM model
- `voice` (string, default: "female2") - TTS voice
- `language` (string) - STT language code
- `vad_threshold` (number, default: 0.5) - VAD sensitivity 0-1
- `eot` (boolean, default: true) - Enable end-of-turn detection
- `tools` (boolean, default: false) - Enable tool calling
- `orchestrator` (string, default: "Zeus") - Orchestrator model for tools

**Audio Format:**
- Input: float32, 16kHz, mono, little-endian
- Output: float32, 22050Hz, mono, little-endian

**Client → Server Events:**
- `ping` - Keepalive
- `session.update` - Update session configuration
- `conversation.item.create` - Add message to conversation
- `conversation.clear` - Clear conversation history
- `response.create` - Generate response for text input
- `response.cancel` - Cancel ongoing response
- `input_audio_buffer.commit` - Commit buffered audio
- `input_audio_buffer.clear` - Clear audio buffer
- Send raw float32 audio as binary frames

**Server → Client Events:**
- `session.created` - Session initialized with config
- `session.updated` - Session config updated
- `response.created` - Response generation started
- `response.text.delta` - Streaming text chunk
- `response.text.done` - Text response complete
- `response.audio.started` - Audio generation started
- `response.audio.done` - Audio generation complete
- `response.audio.interrupted` - Audio interrupted by barge-in
- `response.done` - Full response complete
- `input_audio_buffer.speech_started` - Speech detected
- `input_audio_buffer.speech_stopped` - Speech ended
- `input_audio_buffer.committed` - Audio committed for processing
- `input_audio_buffer.barge_in` - User interrupted assistant
- `conversation.item.input_audio_transcription.started` - Transcription started
- `conversation.item.input_audio_transcription.completed` - Transcription completed
- `eot` - End-of-turn prediction with probability
- `tool.called` - Tool was called
- `tool.result` - Tool execution result
- `show_image` / `dismiss_image` - Image display events
- `job.started` / `job.progress` / `job.completed` - Background job events
- `error` - Error occurred
- `pong` - Response to ping
- Binary frames: TTS audio output as float32 samples at 22050Hz

---

## Orb - Embeddable Voice Widget

Embeddable voice AI widget for websites with secure session-based authentication.

### POST /v1/orb/session

Create a secure session token for embedding. Requires bearer token.

**Request Body:**
```json
{
  "domain": "example.com",
  "model": "Sigma",
  "voice": "female2"
}
```

**Response:**
```json
{
  "token": "abc123def456...",
  "sessionId": "orb_789xyz...",
  "expiresAt": 1705320300
}
```

### GET /v1/orb/embed

Returns the embeddable Orb HTML/JS widget. Use in an iframe.

**Query Parameters:**
- `token` (string, required) - Session token from /v1/orb/session
- `sessionId` (string, required) - Session ID from /v1/orb/session
- `theme` (string, default: "consciousness") - Visual theme
- `mode` (string, default: "particles") - Particle mode
- `autoConnect` (boolean, default: false) - Auto-connect on load

### WS /v1/orb/secure-ws

Secure WebSocket for the embedded Orb. Same protocol as /v1/realtime.

---

## Agent System

AI agent with tool execution, web search, and sandboxed code execution.

### GET /v1/agent/tools

List available agent tools. Requires bearer token.

### POST /v1/agent/message

Send a message to the AI agent. Requires bearer token.

**Request Body:**
```json
{
  "message": "Search the web for the latest AI news and summarize it",
  "tools": ["web_search"],
  "maxTokens": 1000,
  "context": []
}
```

### POST /v1/agent/search

Web search via agent. Requires bearer token.

**Request Body:**
```json
{
  "query": "OpenAI GPT-5 release date",
  "maxResults": 5
}
```

### POST /v1/agent/bash

Execute bash commands in a sandboxed (gVisor) environment. Requires bearer token.

**Request Body:**
```json
{
  "command": "echo 'Hello World'",
  "timeout": 10
}
```

**Response:**
```json
{
  "stdout": "Hello World\n",
  "stderr": "",
  "exitCode": 0
}
```

---

## Embeddings & Vector Search

Text embeddings and vector search for semantic similarity. Uses ONNX models (gte-small from Hugging Face). 384-dimensional vectors.

### POST /v1/embeddings/generate

Generate vector embeddings. Requires bearer token.

**Request Body:**
```json
{
  "text": "The quick brown fox jumps over the lazy dog"
}
```

**Response:**
```json
{
  "embedding": [0.1, 0.2, 0.3, ...],
  "dimensions": 384
}
```

### POST /v1/embeddings/add

Add text and its embedding to a group. Requires bearer token.

**Request Body:**
```json
{
  "text": "Important documentation about our API",
  "group": "docs",
  "metadata": {"source": "readme"}
}
```

### POST /v1/embeddings/search

Semantic search within a group. Requires bearer token.

**Request Body:**
```json
{
  "query": "API documentation",
  "group": "docs",
  "limit": 5
}
```

**Response:**
```json
{
  "results": [
    {"text": "Important documentation about our API", "score": 0.95}
  ]
}
```

### GET /v1/embeddings/groups

List all embedding groups for the authenticated user. Requires bearer token.

### DELETE /v1/embeddings/groups/:name

Delete an embedding group. Requires bearer token.

### POST /v1/embeddings/memory

Add user memory. Requires bearer token.

---

## WebGrep - Web Search & Extraction

Intelligent web search and content extraction. Local alternative to Exa with BM25 relevance scoring, full documentation retrieval, and parallel multi-query research.

### GET /v1/webgrep/status

Check status and capabilities. Returns available search engines and endpoints.

**Available Engines:** duckduckgo, google, brave, startpage, ecosia, kagi

### POST /v1/webgrep/quick-search

Fast relevance-scored search using RAG mode with BM25 scoring. Returns concise, scored chunks.

**Request Body:**
```json
{
  "query": "Prisma createMany limitations",
  "site": "prisma.io",
  "limit": 5,
  "engine": "duckduckgo"
}
```

**Response:**
```json
{
  "query": "Prisma createMany limitations",
  "count": 5,
  "chunks": [
    {
      "title": "CRUD (Reference) | Prisma Documentation",
      "url": "https://www.prisma.io/docs/orm/prisma-client/queries/crud",
      "content": "createMany() uses a single INSERT INTO statement...",
      "score": 8.5
    }
  ]
}
```

### POST /v1/webgrep/documentation

Full documentation page retrieval. Returns larger content blocks for learning APIs or getting comprehensive guides.

**Request Body:**
```json
{
  "query": "Prisma ORM relations documentation",
  "site": "prisma.io",
  "limit": 2,
  "maxContentLength": 8000
}
```

### POST /v1/webgrep/code-examples

Find implementation patterns and code examples. Automatically enhances query with code-related terms.

**Request Body:**
```json
{
  "query": "React useEffect cleanup async",
  "limit": 5,
  "engine": "duckduckgo",
  "site": ""
}
```

### POST /v1/webgrep/scrape

Extract content from a specific URL. Supports RAG mode for relevance-scored chunks.

**Request Body:**
```json
{
  "url": "https://docs.example.com/api-reference",
  "useRag": true,
  "limit": 10,
  "selector": ""
}
```

### POST /v1/webgrep/multi-search

Execute multiple search queries in parallel. Best for research tasks.

**Request Body:**
```json
{
  "queries": ["Prisma vs Drizzle performance", "Prisma limitations 2024", "Drizzle ORM features"],
  "limitPerQuery": 3,
  "engine": "duckduckgo",
  "site": ""
}
```

---

## VPN Proxy Service

VPN proxy service for routing traffic through global servers.

### GET /v1/vpn/servers

List available VPN servers and regions. No authentication required.

**Response:**
```json
{
  "count": 12,
  "servers": [
    {"name": "us16", "region": "United States", "port": "443", "protocol": "tcp"},
    {"name": "uk68", "region": "United Kingdom", "port": "443", "protocol": "tcp"},
    {"name": "de220", "region": "Germany", "port": "53", "protocol": "udp"}
  ]
}
```

### POST /v1/vpn/setup

Initialize VPN service by fetching latest server configurations. Requires bearer token.

### POST /v1/vpn/connect

Establish a proxy connection through a VPN server. Requires bearer token.

**Request Body:**
```json
{
  "server": "us16",
  "proxyType": "socks5"
}
```

**Response:**
```json
{
  "server": "us16",
  "region": "United States",
  "proxyType": "socks5",
  "proxyHost": "api.agentics.co.za",
  "proxyPort": 10800,
  "sessionId": "550e8400-e29b-41d4-a716-446655440000",
  "expiresAt": "2024-01-16T10:30:00Z"
}
```

### GET /v1/vpn/status

Get active VPN session status. Requires bearer token.

### POST /v1/vpn/disconnect

Disconnect a specific VPN session. Requires bearer token. Query param: `session` (session ID).

---

## Payments & Subscriptions

Payment processing via Yoco (South African payment processor). Supports subscriptions and one-time token purchases.

### Token Packages

| Package | Tokens | Price (ZAR) |
|---------|--------|-------------|
| Starter | 100,000 | R29.00 |
| Basic | 500,000 | R99.00 |
| Standard | 1,000,000 | R179.00 |
| Pro | 5,000,000 | R699.00 |
| Enterprise | 20,000,000 | R1,999.00 |

### Rate Limits

- Free: 100 requests/day
- Pro: 10,000 requests/day
- Enterprise: Unlimited

### Endpoints

- GET `/v1/payments/tiers` - List subscription tiers
- GET `/v1/payments/packages` - Token packages
- POST `/v1/payments/subscribe` - Create subscription
- POST `/v1/payments/tokens` - Purchase tokens
- GET `/v1/payments/subscription` - Get subscription details
- POST `/v1/payments/subscription/cancel` - Cancel subscription
- GET `/v1/payments/history` - Payment history
- GET `/v1/payments/balance` - User token balance

---

## Conversations & Memory

### Conversations

- POST `/v1/conversations` - Create conversation
- GET `/v1/conversations` - List conversations
- GET `/v1/conversations/search` - Search conversations
- GET `/v1/conversations/:id` - Get conversation by ID
- POST `/v1/conversations/:id/messages` - Add message to conversation

### Memory (Key-Value Store)

- GET `/v1/memory` - Get all memories
- PUT `/v1/memory/:key` - Set memory value
- DELETE `/v1/memory/:key` - Delete memory

---

## MCP - Model Context Protocol

Manage and interact with MCP servers for extending AI agent capabilities.

- GET `/v1/mcp/servers` - List MCP servers
- GET `/v1/mcp/servers/:name` - Server status
- GET `/v1/mcp/servers/:name/tools` - Server tools
- POST `/v1/mcp/servers` - Add server
- DELETE `/v1/mcp/servers/:name` - Remove server
- POST `/v1/mcp/tools/call` - Call MCP tool

---

## CDN & Widgets

Embeddable web components and widget libraries served via CDN.

- GET `/cdn/agentx-element.js` - Web component
- GET `/cdn/agentx-components.js` - Component library
- GET `/cdn/agentx-powerboard.js` - Powerboard widget
- GET `/cdn/agentx.js` - Full bundle
- GET `/cdn/agentx.css` - Styles

---

## SDKs

Drop-in replacement SDKs that route through the Agentics API instead of directly to providers.

### @agentics/openai

Drop-in replacement for OpenAI SDK.

```bash
npm install @agentics/openai
```

**Features:** Chat completions, Streaming, Image generation (DALL-E compatible), Audio transcription (Whisper compatible), Text-to-speech, Embeddings

### @agentics/anthropic

Drop-in replacement for Anthropic SDK.

```bash
npm install @agentics/anthropic
```

**Features:** Messages API, Streaming, Tool use, Vision (images), System prompts

### @agentics/google-generative-ai

Drop-in replacement for @google/generative-ai SDK.

```bash
npm install @agentics/google-generative-ai
```

**Features:** Text generation, Streaming responses, Chat sessions, Image understanding, Audio generation, Token counting

### @agentics/google-genai

Drop-in replacement for @google/genai SDK (Live/Realtime API).

```bash
npm install @agentics/google-genai
```

**Features:** Real-time voice conversations, WebSocket streaming, Audio input/output, Tool calling, Voice activity detection, Session management

---

## Products

### Agentics CLI (`agentics-cli`)

Full-featured AI agent command-line interface with terminal UI (Bubble Tea) and desktop GUI (Fyne).

```bash
npm install -g agentics
```

**Features:**
- 20+ AI models with streaming chat
- Live voice chat via WebSocket
- Voice Activity Detection (Silero VAD)
- Local TTS with ONNX models
- Integrated tools: bash, file editor, search, web search, URL fetch, Python execution, image generation, task management, speech, memory
- Project and user-level configuration
- Conversation persistence

**Configuration:**
- `~/.agentics/settings.json` - User settings
- `.agentics/project.json` - Project settings
- `.agentics/AGENTICS.md` - Custom instructions

### Agentics Taskman (`@agentics/taskman`)

AI-powered task management with TUI and MCP server.

```bash
npm install -g @agentics/taskman
```

**Features:**
- CLI task manager with TUI interface
- MCP server exposing 18 tools via JSON-RPC
- AI-powered reminders using Odin model
- Scheduled checks at 9 AM, 2 PM, 6 PM
- Task CRUD, subtask management, idea tracking
- Modes: daemon, reminder, tui, mcp

### Agentics Audio (`aaud`)

Standalone audio processing CLI and library.

**Modes:**
- `aaud "Hello world" -v female2 -o output.wav` - TTS
- `aaud --stt audio.mp3 -l en` - STT
- `aaud --live` - Live CLI transcription
- `aaud --live -S -p 8765` - WebSocket server
- `aaud --runtime` - Voice commands

**Features:** 4 TTS voices, multi-language STT, VAD (Silero), EOT detection, clipboard mode, auto-type output

### Agentics WebGrep

Rust TUI for lightning-fast web search.

**Features:** Multi-engine (DuckDuckGo, Google, Kagi, Brave, Startpage, Ecosia), BM25 RAG mode, history tracking (SQLite), caching, CSS selector extraction, syntax highlighting, piped output, MCP server integration

### Agentics Tunnel

Rust TCP tunnel for exposing local ports.

```bash
tunnel connect 8000 0 -s tunnel.agentics.co.za
```

**Features:** NAT/firewall bypass, auto-port assignment, HMAC authentication, Render/Docker/Fly.io deployment support

### Agentics Embedding (AGemb)

High-performance C-based vector embedding and semantic search.

**Features:** ONNX inference (gte-small), SQLite storage, cosine similarity ranking, multi-group management, user isolation

### Agentics Studio

Web hosting platform on ur1s.xyz domain.

**Features:** HTML/CSS/JS editor, subdomain management, visit analytics, payment-gated activation (R149/month)

### Agentics Consolidator

TUI process manager for the entire Agentics ecosystem.

**Features:** Auto-discovery of agentics-* projects, real-time log streaming, process control, auto-start, state persistence, systemd service support

### Agentics Live

Desktop application for real-time voice Orb interface. Built with Wails (Go + Web).

### Agentics Markets Live

Real-time financial market data WebSocket server for stocks, crypto, forex with historical candle data.

### Agentics Sandbox

Secure gVisor-based code execution environment for untrusted Bash and Python code with resource limits and policy enforcement.

### AEP - Agentic Event Protocol

Standardized event protocol for triggering AI actions from external systems.

**9 Adapter Types:** Webhook, MQTT, SMS, Email, Filesystem, HTTP Poll, WebSocket, Cron, Process

**Priority Levels:** 1 (Queue) → 5 (Critical interrupt)

---

## Website Pages

The Agentics website at `https://agentics.co.za` serves the following pages:

| Path | Title | Description |
|------|-------|-------------|
| `/` | Home | Main landing page with hero, services overview, product showcase |
| `/models` | AI Models | Explore 20+ AI models for text, images, audio, embeddings |
| `/docs` | Documentation | Complete API reference, guides, integration tutorials |
| `/dashboard` | Dashboard | Account management, subscription, API usage |
| `/pricing` | Pricing | Simple, transparent pricing |
| `/chat` | Chat | Try AI models directly in browser |
| `/demos` | Demos | Interactive AI capability demonstrations |
| `/products` | Products | Suite of AI-powered tools and platforms |
| `/services` | Services | Enterprise AI solutions and consulting |
| `/about` | About | Company mission and story |
| `/login` | Login | Sign in to account |
| `/register` | Sign Up | Create account |
| `/privacy` | Privacy Policy | Data protection information |
| `/terms` | Terms of Service | Terms and conditions |
| `/sitemap.xml` | Sitemap | XML sitemap for search engines |
| `/robots.txt` | Robots | Crawler directives |
| `/llms.txt` | LLMs.txt | Machine-readable platform overview |
| `/llms.md` | LLMs.md | Full platform documentation |

---

## Technology Stack

**Languages:** Go (primary backend), Rust (CLI tools, tunnel), C (embeddings), TypeScript/JavaScript (web, SDKs), Python (ML training), Kotlin (Android)

**Frameworks:** Gin (Go web), Bubble Tea (TUI), Fyne (Desktop GUI), ONNX Runtime (ML inference), Gorilla WebSocket (real-time), Tokio (Rust async)

**Databases:** MongoDB (primary datastore), SQLite (embeddings, WebGrep)

**AI Providers:** Pollinations, Groq, HuggingFace, OpenRouter, Gemini, DeepSeek, Anthropic, OpenAI, DuckDuckGo, KoboldAI

**Payments:** Yoco (South African payment processor)

**Deployment:** Systemd services, Docker, Render.com, Fly.io

---

## Contact

- **Company:** Agentics
- **Website:** https://agentics.co.za
- **API:** https://api.agentics.co.za
- **Email:** connor@agentics.co.za
- **Phone:** +27 73 541 5134
- **Tunnel Server:** tunnel.agentics.co.za