Open-source cryptography and governed AI, so you can inspect, extend, and trust every layer of your identity and data verification stack.

Zakapi is built on community-audited zero-knowledge libraries, SQL-aware PLONKish circuits, and open identity standards, inspired by PoneglyphDB-style non-interactive verification over committed datasets. Instead of proving arbitrary SQL over a hidden warehouse of sales or logistics data, Zakapi applies the same ideas to identity, KYC, AML, and risk tables. From Circom and Halo2 IPA-based proof systems with custom gates for range checks, sorting, joins, and aggregations, to Aries, W3C Verifiable Credentials, OIDC for Verifiable Credentials, and DIDComm, the platform stays transparent and interoperable by design. AI assists with circuit testing, query/policy simulation, and anomaly detection in proof logs, but cryptographic commitments and open code remain the source of truth—giving your teams a stack they can audit, compose with existing SQL data stores, and rely on for the long term.

Book a consultation

ZAKAPI LAYERS
ZAKAPI LAYERS (PoneglyphDB-style, end-to-end)Each Zakapi layer maps cleanly onto the PoneglyphDB-style pipeline of data → commitment → query → proof → verification → audit.
Zakapi Wallet – user wallet (mobile + web) built on Hyperledger Aries Bifold

Holds the user’s verifiable credentials and proof configurations.
Conceptually, it’s the client-side view of rows in the “identity” tables used in Poneglyph-like circuits.
When a verifier asks a question (“Is age ≥ 18?”, “Is this user KYC’d?”), the wallet participates in building a proof over the relevant committed data.

Issuer Service – issues VCs + ZK-ready claims, implemented as Rust microservices using Aries Cloud Agent

Normalizes raw identity data into structured, SQL-like credential schemas.
Each issued credential becomes a row in a committed table (e.g., Person, KycResult, SanctionScreening).
Issuance updates are captured in commitments so future proofs are always over current, well-defined datasets, just like PoneglyphDB’s committed relations.

Verifier Service – validates credentials and ZK proofs using SnarkJS / Rapidsnark

Plays the role of the PoneglyphDB verifier, checking non-interactive proofs against:
A known verification key,
The current public commitment to issuer datasets and audit logs,
The expected query/policy semantics.
No raw user data is required, only the result and its proof.

Compliance / Proof Engine – ZK circuit & proof layer on Circom (plus Halo2/Noir as we grow)

This is Zakapi’s PoneglyphDB-equivalent circuit layer:
Range gates: “age ≥ 18”, “score in band [700, 850]”, “risk < 0.5”.
Join gates: join identity rows with KYC/AML providers’ results or government eID tables.
Aggregation gates: count, sum, thresholds (e.g., “no more than N failed checks in last 30 days”).
Sort / group-by style logic for more complex policies (e.g., “earliest KYC date”, “recent activity patterns”).
Circom (with Groth16/Plonk), Halo2, and Noir give us the PLONKish, SQL-aware circuit machinery PoneglyphDB uses, adapted to identity and compliance queries.

Trust & Logging Layer – event-sourced audit + revocation on Apache Kafka (+ DB)

Like PoneglyphDB’s commitment to a fixed dataset, Zakapi maintains an append-only, event-sourced log of:
Credential issuance and revocation events,
Policy changes,
Proof requests and outcomes.
These logs can themselves be summarized and committed so auditors can verify:
“This proof was generated against exactly this state of credentials and revocations.”
“No proofs were generated outside the approved policies.”

Developer Cloud / Sandbox – hosted test issuers/verifiers on Kubernetes

A testbed where teams can:
Define SQL-like policy queries over mock identity tables,
See the resulting circuits and proof flows,
Validate that Poneglyph-style non-interactive proofs behave as expected before going to production.

Admin / Governance Console – ops & policy UI as a React/TypeScript SPA

A governance layer where non-cryptographers manage:
Schema definitions (“which fields exist in this credential table?”),
Policy templates (“SQL-like where-clause policies compiled into circuits”),
Key rotation, commitments, and audit modes.
Behind the UI, everything compiles into concrete query plans and circuits, echoing PoneglyphDB’s “SQL → PLONKish circuit” pipeline.

Architecture

Verify With Open Code, Not Blind Trust

Experience the strength of open-source, zero-knowledge cryptography. Just as PoneglyphDB replaces “trust the database” with “verify the SQL proof”, Zakapi replaces “trust the identity provider” with non-interactive proofs over committed identity tables.
We rely on community-audited libraries and AI-assisted checks to generate and verify proofs quickly across web and mobile. Verify facts like age, KYC/AML status, or risk signals as if you were running a SQL query over the underlying data, but see only the result and a proof—never the raw rows.

Audited open-source code

Benefit from publicly inspectable, peer-reviewed cryptography and identity libraries for stronger security and reliability. The proving/verifying code is available for your security teams to evaluate, much like inspecting a PoneglyphDB circuit library.
Optimized verification

Enjoy fast, lightweight proof generation and verification tuned for real-world traffic and devices. SQL-style policies compile into compact PLONKish circuits with efficient custom gates rather than bloated boolean circuits.
AI-assisted protection

Use intelligent monitoring and anomaly detection to spot unusual proof patterns early, strengthening your overall security posture. AI guards the pipeline; math provides the guarantees.

Verify with math. Scale with AI.
Open code. Private proofs. Trusted identity.

Build on Open Code and Intelligent Security

Zakapi’s stack combines open-source cryptography, open standards, and carefully governed AI. Our technology is transparent, peer-reviewed, and interoperable—creating a foundation you can inspect, audit, and align with PoneglyphDB-style correctness guarantees for privacy-preserving digital identity.

PoneglyphDB-Inspired Architecture for Identity and Compliance

PoneglyphDB shows how to:

Commit to a database (e.g., via IPA/KZG polynomial commitments).
Compile SQL queries into PLONKish circuits with custom gates (range, sort, join, group-by).
Prove non-interactively that results are correct over the committed dataset.

Zakapi takes this pattern and applies it to identity and risk data:

We treat credentials, KYC results, sanctions checks, and risk scores as relational tables.
Policies like “age ≥ 18”, “not on sanctions list”, “credit score in band”, or “KYC passed within 30 days” are modeled as SQL-like predicates and aggregations.
Our proof engines compile those policies into PLONKish circuits, reusing Poneglyph-style gates (range checks, joins, group-bys, orderings) so verifiers get single, non-interactive proofs bound to specific, committed datasets and credential states.

You don’t just “trust the API”. You verify with math over a defined schema, with proofs that can be independently checked.

Zero-Knowledge Cryptography Libraries (the “SQL circuit layer”)

We assemble open ZK toolchains to express identity and risk policies as PoneglyphDB-style circuits:

Circom & SnarkJS / Rapidsnark

What they are:

Circom: a leading open-source language for ZK circuits.

SnarkJS: JS/WASM prover/verifier; Rapidsnark: high-performance C++ prover.

How we use them (PoneglyphDB alignment):

We encode many policies as Circom circuits that mirror SQL predicates and joins:

Age thresholds (WHERE age ≥ 18),

Risk thresholds,

Membership in a “sanctions screened” table,

Combinations of credential tables (joins).

These circuits use custom gadgets analogous to Poneglyph’s range and join gates.

SnarkJS and Rapidsnark generate proofs non-interactively; verifiers can run inside browsers or backend services.

Halo2

What it is:

A Rust implementation of a PLONKish proving system supporting recursion and custom gates.

Our usage:

Halo2 is our backbone for complex, multi-credential proofs that look like multi-table SQL joins and aggregates.

We adopt Ethereum Foundation’s KZG-backed variants, enabling commitment schemes similar to those in PoneglyphDB.

Recursive proofs let us compose multiple identity queries into a single compact proof, much like composing multiple SQL subqueries.

Noir (Aztec)

What it is:

A high-level ZK programming language for writing circuits more like normal code.

Our plans:

We prototype policy templates in Noir that correspond to parameterized SQL queries over identity tables.

This keeps circuits portable across proof systems and makes authoring more accessible to developers comfortable with SQL.

STARK frameworks (Plonky2, Starky, etc.)

Role in the stack:

STARK-based frameworks help with high-throughput, audit-log–style proofs, such as:

“This monthly audit report faithfully summarizes all proof events,”

“These risk metrics are correctly computed from the raw event log.”

They echo the Poneglyph idea of committing to a large dataset and proving aggregate queries, but focused on logs and telemetry.

Security Testing Tools & zkFuzz

We integrate tools like zkFuzz into CI to fuzz-test circuits—similar to stress-testing SQL query circuits in PoneglyphDB—so we catch vulnerabilities and constraint mis-specifications early.

Why open-source ZK matters:

Like PoneglyphDB, Zakapi relies on publicly vetted math and implementations. You can inspect how we encode identity policies into circuits, how we commit to datasets, and how proofs are constructed—no black-box cryptography.

SSI & Wallet Frameworks (the “data and schema layer”)

PoneglyphDB assumes structured tables and schemas. Zakapi provides those schemas via open identity standards:

W3C Verifiable Credentials & DIDs – define the tables and rows of your identity domain.

Hyperledger Aries (wallets and agents) – provide standard protocols for secure issuance and presentation.

Indy / AnonCreds, OIDC, SAML, DIDComm – ensure your “identity tables” are interoperable across ecosystems and legacy systems.

In practice:

A university degree VC is a row in a Degrees table.

A KYC check VC is a row in a KycResults table.

Proofs then act like PoneglyphDB queries:

SELECT EXISTS(...) FROM KycResults WHERE subject = user AND status = 'PASS' AND issued_at > NOW() - 30 days.

Zakapi compiles this into a circuit and produces a non-interactive proof, verifiable by any relying party that understands the schema and holds the commitment.

Integration with Identity Sources & KYC Providers (filling the tables)

Zakapi doesn’t replace existing identity systems—it normalizes them into committed tables:

Government eID (Aadhaar, BankID, SingPass, UAE Pass, eIDAS/EUDI)

Telco-based Mobile Connect

Commercial KYC/AML providers (Onfido, Trulioo, Jumio, ShuftiPro)

Sanctions and PEP screening, credit bureaus, and more

Each integration becomes a table or view in the Zakapi “identity database”:

GovernmentID, BankKYC, SanctionScreening, CreditScoreBand, etc.

These tables feed the PoneglyphDB-style circuits:

joins between providers,

range checks on scores or dates,

group-bys or counts for behavioral rules.

The output is always: reusable, zero-knowledge credentials and proofs, not raw API responses.

AI & ML in the Stack (scale and safety, not trust)

In PoneglyphDB terms, AI never changes the database or proof rules—it just helps you reason about them.

Crucially, AI is never the root of trust. Final decisions and guarantees come from mathematics + open code + human review, just as PoneglyphDB’s guarantees come from cryptography, not heuristics.

Smarter circuit design

AI suggests refactors that reduce constraints or reuse gates more efficiently (e.g., combining range checks), inspired by PoneglyphDB’s focus on low-degree, efficient gates.
Automated test generation

Models propose diverse test vectors for policy circuits (“weird edge-case inputs”), ensuring SQL-like policies behave as intended under ZK.
Operational anomaly detection
ML scans metrics and logs:
- Unusual spikes in proof failures,
- Abnormal patterns in verifier requests,
- Latency anomalies in specific circuits.
Compliance & document processing

AI helps map regulatory requirements (GDPR, eIDAS, etc.) into concrete policy templates that we then implement as verifiable circuits.

Community and Collaboration

Being built on open source, Zakapi lives in the same spirit as PoneglyphDB’s academic and open ZK ecosystem:

Our security posture is strengthened by public review and a bug bounty program. You can reason about our system the way you’d reason about PoneglyphDB: by looking at the math, the circuits, and the code.

We contribute fixes and performance improvements to Circom, Halo2, Aries, and related libraries.

We participate in interop plugfests, ensuring Zakapi proofs and credentials work across wallets and agents.

We publish SDKs, docs, and reference circuits on GitHub so others can:

Inspect our “SQL→circuit” patterns,
Fork them,
Propose optimizations or new policy templates.

Orchestrate Your Open-Source & AI Stack

Embrace a transparent, standards-based foundation for digital identity. Zakapi’s platform is built on open-source cryptography and modern AI tooling, so every component is inspectable, upgradable, and portable across environments. Avoid vendor lock-in while keeping full control over how your security and data stack evolve with PoneglyphDB-style non-interactive verification at the core.

Open-source foundations

community-audited cryptography, wallets, and circuits.
AI-assisted security

anomaly detection, intelligent monitoring, automated testing.
Interoperable standards

W3C, DID, OIDC, Hyperledger/OpenWallet, and more.

Join a collaborative ecosystem

Building with transparency and openness

Zakapi plugs into government eID, KYC/AML providers, and existing bank and fintech systems, wrapping their outputs in reusable, privacy-preserving proofs. Workflow engines, observability tools, and deployment scripts are all built on open-source projects, so you orchestrate proofs, automate checks, and ship to any environment while keeping full visibility and control over how your identity infrastructure evolves.

Open foundations, intelligent defenses.

Pair community-reviewed cryptography with AI-aware operations to modernize your security posture without locking into a black box. Zakapi plugs into government eID, KYC/AML providers, and existing bank and fintech systems, wrapping their outputs in reusable, privacy-preserving credentials. Workflow engines, observability tools, and deployment scripts are all built on open-source projects, so you orchestrate proofs, automate checks, and ship to any environment while keeping full visibility and control over how your identity infrastructure evolves.

ZAKAPI LLC

65 BROADWAY, NEW YORK, NY 10001
hello@zakapi.com
+1 (347) 680-0811