Developer Tools Detected

RiNET technical content is protected intellectual property. This platform documents a sovereign-grade civic intelligence operating system. Code inspection, content scraping, and reverse engineering are not permitted.

Request developer access instead

Civic Intelligence Operating System

Most platforms sell you a dashboard.
RiNET sells you the ability to see through walls.

A sovereign, self-improving AI operating system — AI that builds AI. We turn your existing applications into RiNET-powered platforms that reason, learn, and improve themselves, on sovereign European infrastructure.

7Cortex layers
1.8MResolved entities
32KStatutes indexed
// SOVEREIGN AI OPERATING SYSTEM

One million vectors. Three hundred units. A system that teaches itself.

...vectors
...court decisions
...units working now

RiNET is a sovereign, self-improving AI operating system running on European infrastructure: it reads, links and reasons across law, procurement and civic data, and improves itself in a loop that never sleeps.

The live 3D map of the running system, the full architecture and the source code are built for a large screen. Open this page on a laptop or desktop.

Email me the link
Get early access
Read the code: EUR 100 incl. VAT
Live · operations console

One screen. The whole fleet.

This is the view the system has of itself, rebuilt from the same public feed that powers the map above. Nothing here is a screenshot.

RINET / FLEETFEED 30 sEU-SOVEREIGNREAD-ONLY
PRODUCT GROUPS
SWEEP 360 · LIVE
UNIT FIELD
FLEET
-
units
-
working now
-
vectors
GPU NODE
- util · - vram · -
ACTIVITY (SAMPLED)
LIVE FROM PRODUCTION

The running system, not a mockup.

Every point is a real unit of the production fleet, a service or a scheduled job, grouped by the product it serves. Bright points are working right now. The numbers refresh every 30 seconds from the platform's own telemetry; names and internals are withheld.

drag to rotate
0
vectors in the semantic memory (legal corpus, two index generations)
0
court decisions indexed
0
decision-to-statute links resolved
0 / 0
units working right now
GPU inference node
Self-improvement in progress

    Hosted on three servers in the EU, one encrypted backbone. Scale, not slides: these counters move while you read them. Read the code behind this map.

    Blueprint · sovereign by design

    Three servers. One private mesh. A second site on standby.

    Compute, front and data live on separate machines joined by an encrypted WireGuard network. A disaster-recovery site in Helsinki keeps a copy. Nothing in the middle belongs to anyone else.

    COMPUTE · GPU NODEFRONT · WEB & EDGEDATA · CORPUS & STATEDISASTER RECOVERY · HELSINKI inference · embedding · agentspublic sites · gateways1M+ vectors · legal corpusWireGuard mesh · encrypted
    What runs on it

    Our software, by the numbers it keeps.

    Each line is a product family of the live fleet. The name and the number come straight from the running system.

    /01 
     
    -UNITS
    /02 
     
    -UNITS
    /03 
     
    -UNITS
    /04 
     
    -UNITS
    /05 
     
    -UNITS
    /06 
     
    -UNITS
    /07 
     
    -UNITS
    /08 
     
    -UNITS
    Restricted · reference implementations

    Behind the door.

    Everything above runs in production. Most of what makes it work is not on this page. Six reference modules, written like a textbook: every line explained, every assumption stated. Take the idea, never the keys.

    0units in the live fleet
    0vectors of memory
    0self-improvement cycle
    INSIDE
    MODULE 01

    The Gate

    Access with no session store. A signed token that proves itself, and a web server that asks before it serves.

    # stateless, verifiable, expires on its own
    def verify(token, key):
    body, sig = token.rsplit(".", 1)
    ok = compare(sign(body, key), sig)
    return ok and not expired(body)
    INSIDE
    MODULE 02

    The Meter

    How a live system shows its pulse to the world without leaking a single internal name.

    # whitelist in, anonymise, push atomically
    def publish(graph):
    safe = [pick(n, ALLOWED) for n in graph]
    write_tmp(safe); rename(tmp, FEED)
    # nothing else ever leaves
    INSIDE
    MODULE 03

    The Till

    Pay once, unlock for a year. The server asks the payment provider, never the browser.

    # trust the provider, not the redirect
    def unlock(session_id):
    s = provider.fetch(session_id)
    if s.paid and s.product == "access":
    return grant(cookie, days=365)
    INSIDE
    MODULE 04

    The Loop

    A system that reads its own results, finds what fell short, and proposes the next change.

    # observe - judge - propose - verify
    while True:
    gaps = judge(observe())
    plan = propose(gaps)
    ship(plan) if verify(plan) else log(plan)
    INSIDE
    MODULE 05

    The Memory

    Answers with a source or no answer at all. Retrieval over a corpus of a million vectors.

    # no citation, no claim
    def answer(q):
    hits = search(embed(q), k=8)
    if not grounded(hits): return None
    return compose(q, hits, cite=True)
    INSIDE
    MODULE 06

    The Reflex

    Measurement that listens first. What a browser may say, and what it must be asked.

    # consent is a precondition, not a banner
    def signal(kind):
    if not consent.allows(kind): return
    queue.push(minimise(collect(kind)))
    Open the door — EUR 100 incl. VAT →
    One payment, twelve months of access. Registration first, so we know who is reading. New modules are added to your access as they are released.
    The Problem

    Governments generate oceans of data. And drown in them.

    In a country with €2.9B in annual public procurement, 32,375 active statutes, 307,329 legal articles, 1.8 million registered companies, and 70,000 civic associations — the question is never whether the data exists. The question is whether anyone can see through it fast enough to matter.

    Croatia is our proof point. The same forensic problem exists in every democracy: fragmented registries, inconsistent identifiers, disconnected financial flows, opaque beneficial ownership chains, statutes that reference other statutes that reference court decisions from fifteen years ago. The data is technically public. It is also, in practice, unreachable.

    Existing solutions treat symptoms. Dashboards present what you already knew. BI tools require you to know what question to ask. OSINT platforms dump raw feeds and call it transparency. None of them resolve entities across schemas. None of them reason temporally across thirty years of regulatory change. None of them build the graph.

    RiNET does not compete with these tools. It is the substrate beneath them. The layer that makes "who owns this" and "is this legal" and "has this happened before" answerable in under 200 milliseconds, across every public dataset in a sovereign territory, with citation-grade provenance for every answer returned.

    Architecture

    Seven layers. No shortcuts.

    RiNET is structured as a vertical cortex — seven distinct computational layers, each responsible for one transformation in the path from raw heterogeneous input to structured, query-ready intelligence. Every layer is independently replaceable. No layer assumes anything the layer below cannot prove.

    07
    Interface & Orchestration
    Query routing, access control, session fabric. The only layer that speaks to humans and machines.
    Avg response
    142 ms
    06
    Agent Swarm Fabric
    Autonomous agents for ingestion, verification, anomaly detection, and continuous self-improvement. 666 specialized workers under centralized orchestration.
    Active agents
    666 / 666
    05
    Temporal Graph Fabric
    Time-aware relationship graph across people, companies, statutes, contracts, and events. Every edge carries a validity interval.
    Graph nodes
    164,583
    04
    RiNET Vector Cortex
    High-dimensional semantic retrieval across seven distinct collections. Multilingual, temporally aware, legally annotated.
    Indexed vectors
    6.87M
    03
    Entity Resolution Engine
    Deterministic + probabilistic identity reconciliation across OIB, MB, VAT, passport, and implicit identifiers. Audit-grade linkage.
    Entities resolved
    1.8M
    02
    Normalization & Ontology Layer
    Schema harmonization, unit normalization, currency conversion (HRK → EUR), encoding repair. The layer that turns noise into substance.
    Transforms
    47 modules
    01
    Ingestion Substrate
    Continuous ingestion from 40+ sovereign sources: court registries, procurement portals, legal databases, financial statements, property registers, EU law.
    Records / day
    ≈180K

    Every layer exposes a stable internal contract. Every transformation is auditable. Every output is traceable to its source.  ·  Read the full architecture documentation →

    // Live Topology

    The seven layers, drawn to scale.

    Every node above corresponds to a running service in production. This diagram shows the physical topology — three servers, one encrypted backbone, no shortcuts taken in the wire.

    Animated packet flows. Real ports. Real services.  ·  Open in full-screen →

    Cortex Deep Dive

    The Vector Cortex is not a database.

    It is a reasoning substrate. Every question asked of RiNET descends through the cortex, touches every relevant memory, reconciles against the temporal graph, and returns with a provenance trail. The cortex does not retrieve. It reasons.

    C.01

    Multi-lingual semantic recall

    RiNET indexes content across seven vector collections, each optimized for a distinct domain: legal text, corporate records, procurement contracts, court rulings, news streams, technical documentation, and conversational memory. Query any language. Retrieve across all.

    Dimensions: 1024Languages: 47
    C.02

    Entity-aware retrieval

    Semantic search is not enough. RiNET binds every retrieved passage to the resolved entity it describes. A query about "the procurement officer at KBC Rijeka in Q2 2024" returns the person, their role-at-time, the contracts they signed, the outcomes, and the legal framework in effect that quarter.

    Entities bound: 1.8MAccuracy: 96.4%
    C.03

    Temporal graph reasoning

    Every edge carries a validity window. When a company changes ownership, when a statute is amended, when a person leaves a role — the graph does not overwrite. It layers. Ask a question about 2021 and RiNET answers with the state of the world in 2021, not the state of the world today.

    Nodes: 164KEdges: 891K
    C.04

    Citation-grade provenance

    Every answer RiNET returns carries an audit chain: source document, extraction model, normalization transform, resolution confidence, graph traversal path. There is no "AI said so." There is only "this answer came from these fifteen documents, reconciled against this statute, as amended on this date."

    Citation depth: 15 avgHallucination: 0.3%
    C.05

    Forensic anomaly detection

    Continuous scanning identifies patterns that should not exist. Procurement clusters with identical winning margins. Board members appearing across mutually-exclusive competitor structures. Legal entities with matching fingerprints but different names. RiNET finds them. It does not judge them. It surfaces them for the humans who should.

    Patterns tracked: 127Critical findings: 1,500+
    C.06

    Zero-retention conversational memory

    The conversational interface (DABI) is ephemeral by design. Nothing a user asks is retained beyond the session unless explicitly marked for continuity. Sensitive queries leave no trace. Transparent queries build institutional memory. The distinction is user-controlled, cryptographically enforced.

    AES-256OTS-anchored audit log
    Intelligence Fabric

    Six hundred and sixty-six agents. One orchestrator.

    RiNET does not run on a cron schedule. It runs on a swarm. A centralized orchestrator decomposes every operational requirement into atomic tasks, delegates to specialized workers, and reconciles results against a shared ontology. The humans who operate the system talk to exactly one agent. That agent does the rest.

    The architecture inverts the usual pattern. Traditional platforms expose dashboards and assume humans will compose the right questions. RiNET exposes a single reasoning partner (DABI) and assumes humans will ask about outcomes. "Flag every procurement contract above €100K awarded in the last twelve months where the winning bidder was incorporated less than six months before the tender announcement" is not a query to build. It is a sentence to type.

    Beneath DABI, six hundred and sixty-six specialized agents execute. One central orchestrator. Five core cognitive domains (Legal, Financial, Civic, Sentinel, Journalist). Sixty mid-level coordinators. Six hundred task-specific workers. The number is not symbolic. It is the measured steady-state fleet size under current operational load.

    Agents spawn new agents. Agents retire obsolete agents. The swarm rebalances in real time against workload and observed performance. Every agent executes within strict sandboxing. Every agent logs to the same immutable audit trail. The swarm cannot be observed. The swarm's output can be audited to the character.

    Data Substrate

    The substrate under the substrate.

    Numbers are not the product. Numbers are the evidence that the product is real. The following are measured values from production infrastructure as of the current operational quarter.

    DomainAssetVolume
    CorporateResolved legal entities (companies, institutions, associations)1,809,421
    CorporateBeneficial ownership relationships447,289
    LegalStatutes, regulations, ordinances (active + historical)32,375
    LegalLegal articles indexed and vectorized307,329
    LegalCourt notices (e-oglasna) with OIB cross-linkage92% coverage
    FinancialRGFI financial statements imported (1996–2025)1,864,712
    FinancialPre-2023 records converted HRK → EUR100%
    ProcurementPublic tenders indexed (domestic + EU-SIMAP)273,118
    ProcurementForensic anomaly findings (critical + high severity)1,507
    PersonsOIB-enriched individuals with role attribution177,041
    Asset declarationsImovinske kartice (public officials)161,000+
    Vector memoryIndexed passages across seven collections6,870,543
    GraphNodes · Edges164,583 · 891,247
    KnowledgeDABI Q&A pairs under continuous retrieval10,664
    TrainingLLM fine-tuning records (Croatian legal corpus)14,666
    IngestionRecords processed per 24-hour window≈180,000
    Query latencyMedian end-to-end (entity lookup, p50)142 ms
    Query latencyp95 (complex graph traversal)487 ms
    UptimeService level (last 90 days)99.94%
    Hallucination rateMeasured across 6,400 evaluator Q&A pairs0.3%
    Security Architecture

    Sovereign-grade, not enterprise-grade.

    The difference matters. Enterprise-grade security assumes a commercial adversary. Sovereign-grade security assumes a state-level adversary — or a state-level regulator asking whether your claims are true.

    S.01

    Encryption at rest and in transit

    AES-256 for all persistent stores. TLS 1.3 minimum for all transport. Per-tenant key derivation. No shared encryption contexts between clients. Key rotation is automated and auditable.

    S.02

    Blockchain-anchored audit log

    Every administrative action — every data ingestion, every configuration change, every user session — is hashed and anchored to a public proof-of-stake chain (Polygon). The audit trail cannot be altered after the fact without global public evidence of alteration.

    S.03

    GDPR-native data model

    Data subject rights are not a feature. They are a schema constraint. Right to access, right to rectification, right to erasure, right to restriction — each is implemented as a first-class database operation with guaranteed propagation across all derivative layers.

    S.04

    DPIA-ready by design

    A Data Protection Impact Assessment for RiNET requires seventeen pages of policy documentation. We wrote them first, then built the system to satisfy them. Every deployment ships with the DPIA package. No ambiguity. No post-hoc justification.

    S.05

    Zero-trust internal fabric

    No service inside RiNET trusts any other service by default. Every internal call carries a cryptographic assertion of origin, scope, and intent. Lateral movement is architecturally impossible, not merely discouraged.

    S.06

    Forensic readiness

    If something goes wrong, the system is optimized for post-mortem. Every operation emits structured telemetry. Every telemetry line is indexed. A forensic investigator can reconstruct any sixty-second window of system behavior to the individual instruction. This is a feature. It is not cheap. It is worth it.

    API & Developer Platform

    The cortex is addressable.

    RiNET exposes a structured REST API for entity resolution, graph traversal, semantic search, and forensic pattern queries. Full documentation and live playground access are available to registered developers.

    ## Entity Resolution POST /v1/entities/resolve "identifier": "35730331957", "identifier_type": "oib", "as_of": "2025-03-15" Returns: person | company | institution object with resolved confidence, linked aliases, role-at-time, beneficial ownership chain, and temporal validity windows. ## Temporal Graph Traversal POST /v1/graph/traverse "source": "entity:oib:35730331957", "edge_types": ["director_of", "owns"], "depth": 3, "time_window": ["2020-01-01", "2024-12-31"] ## Semantic Cortex Query POST /v1/cortex/query "query": "procurement irregularities KBC Rijeka 2023", "collections": ["legal", "procurement", "news"], "top_k": 20 ## Forensic Pattern Search POST /v1/forensic/patterns "pattern": "shell_company_bidding", "filters": { "region": "PGŽ", "min_contract_value": 100000 }

    Full API reference, live playground, and production keys require registration.

    Free tier: 100 requests/day, sandboxed responses.  ·  Starter & Pro tiers: production data, rate-limited by plan.

    Register for API access   View plans
    Performance

    Numbers that matter.

    Performance in a civic intelligence context is not about transactions per second. It is about time-to-answer for questions that change policy.

    P.01

    Entity resolution

    p50: 42 ms   p95: 128 ms   p99: 342 ms

    Resolves a legal entity across OIB, MB, VAT, historical names, aliases, and mergers. Returns full temporal validity map.

    P.02

    Graph traversal (depth 3)

    p50: 186 ms   p95: 487 ms   p99: 1.2 s

    Three-hop relationship search through beneficial ownership, board overlap, procurement participation, and temporal constraints.

    P.03

    Semantic cortex query

    p50: 94 ms   p95: 223 ms   p99: 610 ms

    Multi-collection vector retrieval with entity binding, reranking, and citation assembly. RAGAS score: 3.7 / 5.0.

    P.04

    Ingestion throughput

    Peak: 14,800 records/min   Sustained: 2,100 records/min

    End-to-end including normalization, entity resolution, vector embedding, graph insertion, and audit-log anchoring.

    Vision 2027–2030

    From transparency OS to decision substrate.

    RiNET today answers questions. RiNET tomorrow answers questions that have not been asked yet. The roadmap is not aspirational. It is sequenced.

    2026

    Sovereign deployment

    First county-level production deployment. Regional regulatory integration. Real-time anomaly alerts to oversight bodies.

    2027

    Multi-region expansion

    Five sovereign territories under live RiNET instances. First EU-wide pilot for cross-border procurement monitoring.

    2028

    EU-wide civic OS

    Standardized cross-member-state entity resolution. EU-Lex fully integrated. Forensic pattern sharing across national oversight bodies.

    2029–30

    Predictive governance

    Policy impact simulation before legislation passes. Early-warning systems for systemic failure patterns. RiNET as decision substrate for democratic governments.

    Deployments

    The first county is listening.

    RiNET is currently in pre-deployment with regional authorities, regulatory bodies, and EU-funded governance initiatives. Full case studies will be published as contractual permissions allow.

    CS.01

    Regional Government — PGŽ

    Coastal-Mountain County pilot for forensic procurement monitoring, regulatory compliance dashboards, and real-time transparency portal for citizens.

    Status: Active engagementPopulation: 287K
    CS.02

    EU Funding Advisory

    DABI EU Fondovi module in operational use for consultancy workflow automation — matching company profiles to open calls, generating feasibility drafts, drafting legal preambles.

    Status: LiveMatches/week: 120+
    CS.03

    Civic Journalism Network

    Continuous anomaly feed for investigative journalists. Pattern-based alerts for procurement irregularities, board-overlap detection, and unusual filing patterns across court registries.

    Status: BetaAlerts/week: 40–60
    Work with us

    Have apps? We make them think.

    Tell us what you run today. We'll show you how the AI RiNET platform turns your existing applications into a sovereign, self-improving AI system — and we can build and operate it for you.

    Prefer to explore first? Book a 30-min demo · developer access