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 →

┌────────────────────────────────────────────────────────────────────────┐
│                         APPLICATION LAYER                               │
│   ┌──────────────┐  ┌──────────────┐  ┌──────────────┐  ┌───────────┐ │
│   │    Zomes     │  │   Contracts  │  │ HOPE Agents  │  │  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  │ │
│   └──────────────┘  └──────────────┘  └──────────────┘  └───────────┘ │
├────────────────────────────────────────────────────────────────────────┤
│                         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

# Test
cargo test --workspace

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

• Rust 1.70 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:8080');

// 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 8080

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.

Apache License 2.0

Copyright © 2019-2025 Apilium Technologies

See LICENSE for the full license text.

Ready to transform your enterprise?

Visit apilium.com  •  Contact Us  •  GitHub

_{Apilium Technologies • Tallinn, Estonia}