The Semantic Infrastructure for Intelligent Applications

Enabling enterprises to build secure, scalable, and intelligent distributed systems

Solutions • Capabilities • Get Started • Website

Modern enterprises face a critical challenge: legacy systems can't keep pace with the demands of IoT, real-time compliance, and intelligent automation. Traditional databases are too slow. Blockchains are too heavy. Point solutions create silos.

AIngle is different.

Built from the ground up as a Semantic DAG (Directed Acyclic Graph), AIngle combines the best of distributed ledgers, graph databases, and edge computing into a single, unified platform.

The Problem: When senior developers leave, they take critical knowledge with them. New team members see what the code does, but not why decisions were made. This creates technical debt and repeated mistakes.

The Solution: Deep Context captures architectural decisions, design rationale, and semantic relationships directly in your development workflow.

Business Impact:

• ✅ 50% faster onboarding for new developers
• ✅ Reduce technical debt from uninformed decisions
• ✅ Audit-ready decision history
• ✅ Searchable knowledge base that grows with your codebase

"Why did we choose microservices for the payment system?"
→ Deep Context returns the original decision, alternatives considered,
  and the business context from 2 years ago.

Explore Deep Context →

The Problem: Financial institutions review customers annually. If an entity appears on a sanctions list today, it can take weeks to detect. Manual processes create compliance gaps and regulatory risk.

The Solution: AIngle's Semantic Compliance monitors sanctions lists in real-time, using graph analysis to detect hidden relationships and fuzzy matching to catch name variations.

Business Impact:

• ✅ Instant detection when sanctions lists change
• ✅ Uncover hidden networks through graph analysis
• ✅ Reduce false positives with semantic matching
• ✅ Immutable audit trail for regulatory proof

Traditional: Annual review → 365-day exposure window
AIngle:      Real-time sync → Minutes to detection

Explore Semantic Compliance →

The Problem: IoT devices have limited resources but need to make intelligent decisions. Cloud round-trips add latency. Connectivity isn't guaranteed. Yet you need security, coordination, and smart behavior.

The Solution: AIngle Minimal runs on devices with less than 1MB RAM, providing full DAG capabilities, peer-to-peer gossip, and embedded intelligence at the edge.

Business Impact:

• ✅ Sub-second decisions without cloud dependency
• ✅ Automatic anomaly detection on-device
• ✅ Mesh networking between devices
• ✅ Zero infrastructure costs for device-to-device communication

Supported Protocols: CoAP • mDNS • Gossip • DTLS

Explore IoT Capabilities →

AIngle supports multi-node clustering via Raft consensus for high availability and horizontal scalability. Writes are replicated to all nodes; reads can be served from any node with optional quorum consistency.

# Node 1 — bootstrap leader
aingle-cortex --port 8081 \
  --cluster --cluster-node-id 1 \
  --cluster-secret "your-secret-at-least-16-chars" \
  --cluster-wal-dir ./data/node1/wal \
  --db-path ./data/node1/graph.sled

# Node 2 — joins via node 1
aingle-cortex --port 8082 \
  --cluster --cluster-node-id 2 \
  --cluster-peers 127.0.0.1:8081 \
  --cluster-secret "your-secret-at-least-16-chars" \
  --cluster-wal-dir ./data/node2/wal \
  --db-path ./data/node2/graph.sled

# Node 3 — joins via node 1
aingle-cortex --port 8083 \
  --cluster --cluster-node-id 3 \
  --cluster-peers 127.0.0.1:8081 \
  --cluster-secret "your-secret-at-least-16-chars" \
  --cluster-wal-dir ./data/node3/wal \
  --db-path ./data/node3/graph.sled

# Auto-generated self-signed certs (development)
aingle-cortex --port 8081 --cluster --cluster-node-id 1 \
  --cluster-secret "your-secret" --cluster-tls

# Custom certificates (production)
aingle-cortex --port 8081 --cluster --cluster-node-id 1 \
  --cluster-secret "your-secret" --cluster-tls \
  --cluster-tls-cert /path/to/cert.pem \
  --cluster-tls-key /path/to/key.pem

• Raft consensus — automatic leader election, log replication, and membership changes
• Streaming snapshots — 512KB chunked transfer with per-chunk ACK for large datasets
• Write-Ahead Log — crash-safe durability with segment rotation and integrity verification
• TLS encryption — optional TLS for inter-node communication (self-signed or custom certs)
• Constant-time auth — cluster secret verified with timing-safe comparison
• Quorum reads — optional strong consistency for read operations

┌────────────────────────────────────────────────────────────────────────┐
│                         APPLICATION LAYER                               │
│   ┌──────────────┐  ┌──────────────┐  ┌──────────────┐  ┌───────────┐ │
│   │    Zomes     │  │   Contracts  │  │   Kaneru     │  │  DAG Viz  │ │
│   │   (WASM)     │  │  (Rust DSL)  │  │    (RL)      │  │  (D3.js)  │ │
│   └──────────────┘  └──────────────┘  └──────────────┘  └───────────┘ │
├────────────────────────────────────────────────────────────────────────┤
│                            API LAYER                                    │
│   ┌────────────────────────────────────────────────────────────────┐  │
│   │              Cortex API (REST • GraphQL • SPARQL)               │  │
│   └────────────────────────────────────────────────────────────────┘  │
├────────────────────────────────────────────────────────────────────────┤
│                          CORE SERVICES                                  │
│   ┌──────────────┐  ┌──────────────┐  ┌──────────────┐  ┌───────────┐ │
│   │  Semantic    │  │    Logic     │  │  ZK Proofs   │  │ Contracts │ │
│   │   Graph      │  │   Engine     │  │  (Privacy)   │  │  Runtime  │ │
│   └──────────────┘  └──────────────┘  └──────────────┘  └───────────┘ │
├────────────────────────────────────────────────────────────────────────┤
│                        CONSENSUS LAYER                                  │
│   ┌──────────────┐  ┌──────────────┐  ┌──────────────┐  ┌───────────┐ │
│   │    Raft      │  │     WAL      │  │  Streaming   │  │   TLS     │ │
│   │ (openraft)   │  │ (Durability) │  │  Snapshots   │  │  (mTLS)   │ │
│   └──────────────┘  └──────────────┘  └──────────────┘  └───────────┘ │
├────────────────────────────────────────────────────────────────────────┤
│                         NETWORK LAYER                                   │
│   ┌──────────────┐  ┌──────────────┐  ┌──────────────┐  ┌───────────┐ │
│   │ Kitsune P2P  │  │    CoAP      │  │   Gossip     │  │   mDNS    │ │
│   │   (QUIC)     │  │   (IoT)      │  │ (Optimized)  │  │ Discovery │ │
│   └──────────────┘  └──────────────┘  └──────────────┘  └───────────┘ │
└────────────────────────────────────────────────────────────────────────┘

# Clone
git clone https://github.com/ApiliumCode/aingle.git
cd aingle

# Build
cargo build --workspace --release

# Build with clustering support
cargo build -p aingle_cortex --features cluster --release

# Test
cargo test --workspace

# Documentation
cargo doc --workspace --no-deps --open

• Rust 1.83 or later
• libsodium-dev (cryptography)
• libssl-dev (TLS)
• pkg-config

# Deep Context - Semantic Git
cd examples/deep_context
cargo run --release -- --help

# Semantic Compliance - AML/KYC
cd examples/semantic_compliance
cargo run --release -- --help

Full API Reference:

cargo doc --workspace --no-deps --open

Official SDKs for integrating AIngle into your applications:

import { AIngleClient } from '@apilium/aingle-sdk';

const client = new AIngleClient('http://localhost:19090');

// Create an entry
const hash = await client.createEntry({ sensor: 'temp', value: 23.5 });

// Subscribe to real-time updates
client.subscribe((entry) => {
  console.log('New entry:', entry.hash);
});

# Start node with REST API enabled
aingle-minimal run --rest-port 19080

We welcome contributions from the community.

1. Fork the repository
2. Create your feature branch
3. Write tests for new functionality
4. Ensure all tests pass: cargo test --workspace
5. Format code: cargo fmt --all
6. Submit a pull request

See our contribution guidelines for details.

Dual License: Apache-2.0 + Commercial

Copyright © 2019-2026 Apilium Technologies OÜ

AIngle is available under two licenses:

• Apache License 2.0 — Free for personal use, education, research, evaluation, and organizations with annual revenue below USD $1M. See LICENSE-APACHE.

• Commercial License — Required for commercial integration, SaaS offerings, and organizations with annual revenue above USD $1M. See LICENSE-COMMERCIAL.

For commercial licensing: partners@apilium.com

Ready to transform your enterprise?

Visit apilium.com  •  Contact Us  •  GitHub

_{Apilium Technologies OÜ • Tallinn, Estonia}