An AI Platform Engineered for Developers
REST and GraphQL APIs, TypeScript-first SDKs, and a layered architecture designed for the way engineering teams actually build — with clear contracts, predictable behaviour, and enterprise-grade security controls from day one.
- 99.99% Uptime SLA
- Sub-100ms API Target
- API Key + OAuth 2.0
- OpenAPI 3.1 Spec
Built for Developers Who Care
A developer platform designed around the things that actually matter when you are building production integrations — consistency, observability, security, and documentation you can trust.
-
Predictable API Performance
Every endpoint is designed with a sub-100ms p99 latency target. No cold starts, no surprise timeouts. You get consistent, documented response behaviour you can reference in your architecture decisions.
-
Full Type Safety
Every SDK ships with complete TypeScript definitions generated from the OpenAPI spec. Your editor autocompletes every method, parameter, and response shape without guesswork.
-
Transparent Pricing Model
Per-request pricing with no hidden multipliers or overage surprises. You can model your costs before you build, not after you receive the first invoice.
-
Built-in Redundancy
Multi-region deployment with automatic failover and a 99.99% uptime SLA. Your integration inherits the same reliability guarantees that enterprise production deployments require.
-
Security Controls Included
API key scoping, JWT authentication, rate limiting, and IP allowlisting are available without additional configuration. Security is part of the platform architecture, not an add-on.
-
Machine-Readable Spec
A complete OpenAPI 3.1 specification ships with every platform release. Import it into Postman, generate your own client library, or validate your integration against the canonical contract.
-
Documentation That Reflects Reality
Every endpoint documented with real request and response examples, error code explanations, and edge case notes. No placeholder text, no aspirational descriptions of features that do not exist yet.
A Layered Architecture You Can Reason About
Each layer of the Aigenttra platform has a defined responsibility boundary — from the client SDK through to AI inference. Independent scaling, consistent interfaces, and observable behaviour at every level.
Explore the Architecture-
Frontend Layer Client SDK layer designed to support web, mobile, and server-side integrations
-
API Gateway Single entry point for REST, GraphQL, and WebSocket — authentication, rate limiting, and routing handled at this layer
-
Services Layer Business logic layer designed to support agent execution, workflow automation, analytics, and third-party integrations
-
AI Layer Inference layer designed to support foundation models, retrieval-augmented generation, and embedding generation
-
Data Layer Persistence layer designed to support relational data, caching, vector search, and object storage
-
Observability Telemetry layer designed to support distributed tracing, metrics aggregation, structured logging, and threshold alerting
Your Language. Your Stack.
SDKs for major languages, a unified REST API with an OpenAPI 3.1 specification, and a GraphQL endpoint in development. Language availability and current status shown below.
-
JavaScript
Stable -
TypeScript
Stable -
Python
Stable -
Go
Stable -
Java
Early Access -
PHP
Early Access -
REST API
OpenAPI 3.1 -
GraphQL
Planned -
Mobile SDKs
Coming Soon
-
Download Spec
OpenAPI Specification
The full OpenAPI 3.1 specification is available for download and can be used to generate client libraries, validate integrations, or import directly into API testing tools like Postman and Insomnia.
-
Webhook Docs
Webhook Events
Real-time event delivery via HTTPS POST with HMAC-SHA256 signature verification. Failed deliveries are retried with exponential backoff and are inspectable from the developer dashboard.
How a Request Moves Through the Platform
Understanding the request flow helps you integrate correctly, debug effectively, and plan for scale. Each layer has a defined responsibility — from client authentication through to AI inference and response delivery.
-
Client
Your application — browser, mobile, or server
-
API Gateway
Authentication, rate limiting, and request routing
-
Services
Agent execution, automation, analytics, and integrations
-
AI Layer
Model inference, fine-tuning, and embedding generation
-
Data Layer
Relational storage, caching, vector search, and objects
-
Monitoring
Distributed traces, metrics, structured logs, and alerts
-
Security
Encryption at rest and in transit, and immutable audit logging
What Integration Looks Like
Representative examples of how the API is designed to work. These samples illustrate the intended SDK interface — actual package names and method signatures will be confirmed at release.
import { AigenttraClient } from '@aigenttra/sdk'
const client = new AigenttraClient({ apiKey: process.env.AIGENTTRA_API_KEY })
const agent = await client.agents.create({
name: 'DataProcessor',
model: 'aigenttra-pro',
tools: ['web-search', 'code-runner']
})
const result = await agent.run({
input: 'Analyse Q3 sales data and identify trends',
context: { dataset: 'sales_q3_2026.csv' }
})
// Output the execution result
console.log(result.output)
from aigenttra import AigenttraClient
import os
client = AigenttraClient(api_key=os.environ['AIGENTTRA_API_KEY'])
agent = client.agents.create(
name='DataProcessor',
model='aigenttra-pro',
tools=['web-search']
)
result = agent.run(
input='Analyse Q3 sales data',
context={'dataset': 'sales_q3.csv'}
)
print(result.output)
client := aigenttra.NewClient(os.Getenv("AIGENTTRA_API_KEY"))
agent, _ := client.Agents.Create(ctx, &aigenttra.AgentConfig{
Name: "DataProcessor",
Model: "aigenttra-pro",
})
result, _ := agent.Run(ctx, &aigenttra.RunInput{
Input: "Analyse Q3 sales data",
})
fmt.Println(result.Output)
curl -X POST https://api.aigenttra.com/v1/agents/run \
-H 'Authorization: Bearer $AIGENTTRA_API_KEY' \
-H 'Content-Type: application/json' \
-d '{"model": "aigenttra-pro", "input": "Analyse Q3 sales data"}'
mutation RunAgent {
runAgent(input: {
model: "aigenttra-pro",
prompt: "Analyse Q3 sales data"
}) {
output
status
}
}
Getting from Setup to Production
A practical path through the platform — from account creation to a validated, monitored production integration.
-
Register
Create your developer account. No credit card required to access the sandbox environment or documentation.
-
Get API Key
Generate API keys from the dashboard with scoped permissions. Separate keys for sandbox and production from the start.
-
Install SDK
Install the SDK for your language using your package manager, or call the REST API directly without any SDK dependency.
-
Integrate
Follow the Quick Start guide to make your first authenticated API call. The guide covers authentication, request structure, and error handling.
-
Test
Use the sandbox environment to validate your integration end-to-end. Webhooks, agent runs, and error paths can all be tested without touching production data.
-
Deploy
Move to production API keys when your integration is validated. The platform scales to handle your load — no capacity pre-provisioning required.
-
Monitor
Track request volume, latency distributions, error rates, and custom events from your production integration using the observability dashboard.
Tools for Every Stage of Development
From initial integration through production operation, the platform is designed to be manageable from both the terminal and a web dashboard. Current availability shown on each tool.
-
Planned
CLI Tool
A command-line interface for managing API keys, querying logs, triggering test events, and interacting with the platform without leaving your terminal.
Explore -
Web App
Dashboard
Web-based interface for API key management, usage analytics, team permissions, and webhook configuration.
Explore -
Planned
Log Explorer
Search, filter, and inspect API request and response logs with full payload visibility. Useful for debugging integration issues in both sandbox and production.
Explore -
Planned
Analytics
Request volume, latency percentiles, error rate breakdowns, and custom event tracking across your production and sandbox integrations.
Explore -
Coming Soon
Testing Suite
Tooling for API contract testing, sandbox-based integration testing, and mock server generation for local development workflows.
Explore -
Planned
Monitoring
Uptime tracking, threshold-based alerting, and SLA reporting for teams who need operational visibility into their Aigenttra integration.
Explore -
Coming Soon
SDK Generator
Generate idiomatic client libraries in any language directly from the OpenAPI 3.1 specification. Useful for languages without an official SDK.
Explore -
Free
Sandbox
A fully isolated environment that mirrors production capabilities. Test API calls, webhooks, and integrations without any risk to live data or billing.
Explore
Documentation That Works Like a Colleague
Every API endpoint documented with real request and response examples, error code explanations, and implementation notes written for engineers — not marketing copy.
Browse All Documentation-
Quick Start
Get your first API call working in under 5 minutes
4 articles -
API Reference
Complete endpoint documentation with request/response examples
127 articles -
Authentication
API keys, JWT, OAuth 2.0, and enterprise SSO guides
12 articles -
Webhooks
Real-time event delivery, HMAC verification, retry logic
8 articles -
SDKs & Libraries
Language-specific SDK guides and migration notes
9 articles -
Guides & Tutorials
Step-by-step implementation guides for common use cases
34 articles -
Changelog
Release notes, breaking changes, and deprecation notices
89 articles
Popular searches
Authentication and Security Controls
Every Aigenttra API call passes through a consistent authentication and authorisation layer. Security controls are built into the platform architecture — not left to the integrating application to implement.
-
1Client Request
GET /v1/agents Authorization: Bearer sk_live_abc123… -
2Gateway Validation
✓ Token Valid ✓ Scope Check: read:agents ✓ Rate Limit: 994/1000 remaining -
3Service Execution
200 OK Forwarded to internal microservice
-
OAuth 2.0
OAuth 2.0 with PKCE for secure user-authorised API access — designed for applications that act on behalf of authenticated users.
-
API Key Scoping
API keys can be scoped to specific endpoints, resource types, and permitted actions — reducing the blast radius of any key compromise.
-
JWT Tokens
Stateless bearer token authentication with configurable expiry windows and automatic refresh token rotation.
-
Encryption
TLS 1.3 for all data in transit and AES-256 for data at rest. No plaintext storage of sensitive fields at any layer.
-
Rate Limiting
Per-key and per-IP rate limits with burst allowances. Standard Retry-After and X-RateLimit-* response headers on all throttled responses.
-
Audit Logs
Immutable audit trail for every API call — including authentication events, key creation, and permission changes. Exportable for compliance reviews.
-
IP Allowlisting
Restrict API access to specific IP ranges or CIDR blocks. Designed for enterprise deployments where outbound IP addresses are fixed and known.
-
Compliance Posture
The platform architecture is designed with HIPAA, GDPR, and enterprise security requirements in mind. Specific certifications are communicated as they are formally earned.