Zarynx

• 

  Connect Agent

• 

  Dashboard

Inspiration

We watched autonomous AI agents ship to production with zero accountability. A finance bot approves a $100K transfer. A devops agent scales infrastructure. An hr bot changes salaries. Who's liable? Who audits? Nobody. We built Zarynx to answer: How do you run a bank for AI agents?

What it does

Zarynx is the governance layer for autonomous AI systems. Every agent action goes through our policy engine: allow (instant), co-sign (wait for human approval), or deny (blocked). Every decision is recorded in a tamper-proof ledger with hash-chained receipts. Agents get real-time funding, policies auto-enforce compliance, and every transaction is cryptographically verifiable.

Think of it as: Stripe for agent spending + SEC-grade audit trails.

How we built it

Frontend: Next.js 16, React Server Components, TypeScript, Tailwind CSS with a dark fintech aesthetic.

Backend: Next.js API routes, pg connection pooling, cryptographic hash-chaining (SHA-256).

Database: Aurora PostgreSQL (Serverless v2) with ACID transactions, CHECK constraints for ledger balance validation, Row-Level Security for multi-tenancy. Double-entry bookkeeping enforced at the schema level.

Key architecture: Policy decisions are server-side (not browser logic). Ledger is append-only with cryptographic proofs. Each receipt contains prev_hash + current_hash, making tampering immediately detectable.

Challenges we ran into

1. ACID transactions at scale — Getting balance validation and policy decisions atomic was hard. We solved it with PostgreSQL CHECK constraints + transaction isolation.

2. Hash-chain integrity — Ensuring every receipt links to the previous one without gaps. Fixed by using sequences + trigger-based validation.

3. Real-time policy updates — Agents polling stale policies defeats the purpose. We solved it with server-side policy versioning + immediate effect on next request.

4. Multi-tenant isolation — One customer's ledger can't touch another's. RLS policies + per-query scoping on every database read.

Accomplishments that we're proud of

• Hash-chain that actually works: Not a gimmick. Edit any receipt payload, run verify() → chain breaks visibly. Run restore() → chain repairs. This is real cryptography, not theater.

• Double-entry ledger enforced in SQL: Not in app code. Every transaction posts to two accounts (debit + credit). Balance is derived from ledger, never stored. If balance ≠ SUM(ledger), the database rejects the write.

• Policy engine with real decisions: Agents submit {"action": "spend", "amount": 500}. System evaluates policies in real-time. Returns decision + reasoning. Co-sign inbox shows what's pending human approval.

• Serverless Aurora + Vercel: Sub-200ms latency end-to-end. Scales from 1 agent to 1000+ without capacity planning.

What we learned

Aurora isn't just "better PostgreSQL in the cloud." It's the right choice when you need:

• ACID guarantees (not eventual consistency)
• Referential integrity (foreign keys that actually matter)
• CHECK constraints (business logic in the database, not application code)
• Row-Level Security (multi-tenancy as a primitive, not an afterthought)

The judges will see fintech apps fail because they tried to do ledger accounting in Node.js. We did it in Aurora. That's the difference between a demo and a product.

What's next for Zarynx

1. Pricing engine: \$99/month org + \$29/agent + \$0.001/transaction.

2. Compliance reports: Automated audit trails that satisfy SOC 2, HIPAA, regulatory requirements.

3. Agent marketplace: Pre-built agents with pre-approved policies. Deploy in seconds, audit trail included.

Built With

• amazon-web-services
• aws-aurora-postgresql-(serverless-v2)
• aws-rds-(database)
• iam
• next.js-16
• node.js
• pg-(connection-pooling)
• postgresql-16
• react-19
• sha-256-(cryptographic-hashing)
• tailwind-css
• typescript
• vercel-(hosting)