Kronova Asset Intelligence Platform

repository·main·Indexed 42 days ago

https://github.com/kronova-intelligent-systems/asset-intel-orchestration-engine

A convergent enterprise platform for asset management, AI agents, and blockchain services. Features the @kronova-intelligent-systems/sdk for TypeScript/JavaScript, providing programmatic access to asset CRUD, AI agent execution, vector embeddings, on-chain tokenization, and stablecoin management. The platform integrates the Canton Network, Sui blockchain, and a suite of 18 proprietary AI tools for predictive maintenance and asset utilization.

Tokens: 47.3K
Snippets: 135
Records: 179
Agent score: 54%

What's inside Kronova

Overview of Kronova's Enterprise Technology Stack
main
Kronova provides a convergent platform designed to solve 24 critical enterprise problems across asset intelligence, blockchain, AI, and decentralized communication. The stack integrates several high-performance technologies to provide a unified environment for asset management and automation:
- Blockchain & Settlement: Canton Network for enterprise-grade settlement, Sui blockchain for low-cost Move smart contracts ($0.01/transaction), and private stablecoin deployment via Circle USDC xReserve.
- AI & Automation: 18 proprietary AI tools trained on asset intelligence, including predictive maintenance, voice-enabled agents, and self-improving learning systems.
- Connectivity & Security: OAuth 2.1 + Model Context Protocol (MCP) for AI agent authentication, AetherNet P2P protocol for decentralized communication, and Plaid-powered financial connectivity.
- Interface: Voice-first interfaces for hands-free field operations and WCAG 2.1 AAA compliance for accessibility.
https://github.com/kronova-intelligent-systems/asset-intel-orchestration-engine/blob/main/blog/24-enterprise-problems-complete-technology-stack.md
Choose between Custom and Supabase Native OAuth 2.1
main
Resend-It offers two OAuth 2.1 implementation paths depending on your need for control versus ease of use.
Custom OAuth 2.1 (Self-Managed)
Best for:
- Custom authorization logic (e.g., multi-tenant approval workflows).
- Fine-grained control over token generation and custom claims.
- Integrating with external systems (e.g., fraud detection, Enterprise SSO).
- White-labeling OAuth for multiple organizations.
- Requirements for specific audit logging and compliance.
Supabase Native OAuth 2.1 (Managed)
Best for:
- Quick setup with minimal code.
- Standard third-party integrations and MCP (Model Context Protocol) clients.
- Automatic token rotation, refresh, and PKCE validation.
- Leveraging managed infrastructure and Supabase's built-in security.
https://github.com/kronova-intelligent-systems/asset-intel-orchestration-engine/blob/main/docs/OAUTH_ARCHITECTURE.md
Understand the AetherNet transport layer
main
AetherNet is a zero-trust, peer-to-peer (P2P) transport layer built on a libp2p foundation. It is designed to provide secure communication for agentic messages.
Core features include:
- Encrypted message envelopes: Secures all agent communications.
- Byzantine fault tolerance: Ensures multi-agent consensus.
- Privacy-tiered routing: Routes data based on sensitivity levels.
- Sub-second delivery: Optimized for global network performance.
https://github.com/kronova-intelligent-systems/asset-intel-orchestration-engine/blob/main/blog/kronova-a2a-aethernet-payment-protocol.md
Understand the Kronova Agentic Commerce Stack
main
The Kronova ecosystem relies on the convergence of four core technologies to enable autonomous agent commerce:
1. A2A Protocol: The communication language used by agents to discover each other, negotiate, and delegate tasks.
2. AetherNet: A secure, encrypted transport layer that provides a peer-to-peer mesh network for agent communications.
3. Canton Network: A privacy-preserving ledger that provides blockchain-level auditability with enterprise-grade database privacy.
4. Private Stablecoins (e.g., USDCx): Programmable money used for instant, automated settlement of agentic transactions.
Together, these allow for 'Conversational Commerce' where agents can transcribe intent, discover providers via A2A, create Intent Mandates, negotiate pricing, and execute payments via Canton without human intervention.
https://github.com/kronova-intelligent-systems/asset-intel-orchestration-engine/blob/main/blog/kronova-a2a-aethernet-payment-protocol.md

Understand the AetherNet Secure Agentic Payment Protocol (AP2) architecture

main

The payment stack integrates three distinct protocols to move from human intent to autonomous settlement:

AP2 (Agents Payment Protocol): Manages mandates (Intent, Cart, and Payment) to ensure cryptographic certainty of financial actions.
MCP (Model Context Protocol): Provides the tools for agents to interact with the protocol, such as get_quote, sign_mandate, and execute_settlement.
AetherNet: Acts as the secure transport layer using encrypted P2P envelopes and privacy-tiered routing.
Canton Network: Handles the final atomic settlement using privacy-preserving smart contracts and USDCx (Canton-native USDC).

┌─────────────────────────────────────────────────────────┐
│  USER INTENT                                            │
│  "Buy the best server credits for under $200"          │
└─────────────────────┬───────────────────────────────────┘
                      │
                      ▼
┌─────────────────────────────────────────────────────────┐
│  AP2 (Agents Payment Protocol)                          │
│  • Intent Mandate: User authorizes up to $200          │
│  • Cart Mandate: Agent selects $175 option             │
│  • Payment Mandate: Cryptographic execution proof       │
└─────────────────────┬───────────────────────────────────┘
                      │
                      ▼
┌─────────────────────────────────────────────────────────┐
│  MCP (Model Context Protocol)                           │
│  • get_quote tool: Agent queries merchant pricing       │
│  • sign_mandate tool: Agent creates cart               │
│  • execute_settlement tool: Triggers Canton contract   │
└─────────────────────┬───────────────────────────────────┘
                      │
                      ▼
┌─────────────────────────────────────────────────────────┐
│  AETHERNET                                              │
│  • Encrypted P2P message envelope                       │
│  • Privacy-tiered routing to Canton node               │
│  • Byzantine consensus for multi-agent coordination     │
└─────────────────────┬───────────────────────────────────┘
                      │
                      ▼
┌─────────────────────────────────────────────────────────┐
│  CANTON SMART CONTRACT                                  │
│  • Atomic swap: User's USDCx → Merchant's vault        │
│  • Privacy layer: Only parties + auditors see details   │
│  • Digital receipt: Verifiable Credential (VC) issued   │
└─────────────────────────────────────────────────────────┘

Implement multi-tenant isolation in Qdrant searches
main
To ensure data privacy in a multi-tenant environment, every Qdrant search must include a filter in the must clause that matches the specific user_id and org_id of the requesting tenant.
```
const results = await qdrantClient.search(collection, {
  vector: queryEmbedding,
  filter: {
    must: [
      { key: 'user_id', match: { value: userId } },
      { key: 'org_id', match: { value: orgId } },
    ],
  },
  limit: 10,
});
```
https://github.com/kronova-intelligent-systems/asset-intel-orchestration-engine/blob/main/docs/VECTOR_DATABASE_STRATEGY.md
Choose between Custom and Supabase OAuth 2.1
main
Decide which OAuth 2.1 implementation to use based on your requirements:
Use Supabase Native OAuth 2.1 (Recommended) if:
- You want faster setup and managed security.
- You want automatic maintenance and updates.
- You need seamless integration with MCP clients.
Use Custom OAuth 2.1 if:
- You require specific business logic during the OAuth flow.
- You need to implement custom token claims that are not supported by Supabase.
https://github.com/kronova-intelligent-systems/asset-intel-orchestration-engine/blob/main/docs/OAUTH_ARCHITECTURE.md

Compare Supabase pgvector vs Qdrant for vector search

main

When deciding whether to migrate from Supabase pgvector to Qdrant, consider the following advantages provided by Qdrant:

Feature	Supabase pgvector	Qdrant	Advantage
Vector Search Speed	Good	Excellent	10-100x faster for large datasets
Filtering	SQL-based	Native payload filtering	More efficient combined searches
Scalability	Limited by PostgreSQL	Horizontal sharding	Billions of vectors
Memory Efficiency	Full vectors in memory	Quantization options	4-16x memory reduction
Real-time Updates	Full reindex needed	Instant updates	No downtime
Multi-tenancy	Schema separation	Collection namespaces	Better isolation
Hybrid Search	Limited	Native sparse/dense	Better relevance

Respect ResendIt API rate limits
main
While strict enforcement is not currently active, the following limits are recommended to ensure service stability:
- Maximum 100 requests per minute per API key
- Maximum 1000 requests per hour per account
To handle potential rate limiting, implement exponential backoff and cache results where possible. Future updates will include rate limit headers:
- X-RateLimit-Limit: The total limit allowed.
- X-RateLimit-Remaining: The number of requests remaining in the current window.
- X-RateLimit-Reset: The Unix timestamp when the limit resets.
https://github.com/kronova-intelligent-systems/asset-intel-orchestration-engine/blob/main/docs/API_INTEGRATION_GUIDE.md
Verify Webhook Signatures
main
To ensure webhooks are authentic, you must verify the x-resendit-signature header.
Algorithm: SHA256 HMAC Key: Your CLIENT_SECRET Payload: The raw request body string.
Expected Format: sha256=<hex_digest>
Example verification logic:
```
const expectedSignature = 'sha256=' + 
  crypto.createHmac('sha256', CLIENT_SECRET)
    .update(payload)
    .digest('hex');
```
https://github.com/kronova-intelligent-systems/asset-intel-orchestration-engine/blob/main/docs/oauth-integration-guide.md

Understand Data Stream subscription tiers and formats

main

The streaming format (Server-Sent Events or HTTP Polling) is determined by your subscription tier.

Tier	Format	Rate Limit	Max Streams	Poll Interval
Free	HTTP Polling	60/hour	1	30 seconds
Lite	HTTP Polling	180/hour	2	15 seconds
Pro	Server-Sent Events (SSE)	1,000/hour	10	1 second (fallback)
Enterprise	Server-Sent Events (SSE)	Unlimited	Unlimited	1 second (fallback)

Implement dual-write vector synchronization
main
To ensure data consistency during the migration period, implement a VectorSyncService that supports dual-writing to both Supabase and Qdrant. This is controlled by the following environment variables:
- USE_QDRANT: Set to 'true' to enable Qdrant operations.
- DUAL_WRITE_VECTORS: Set to 'true' to write to both Supabase and Qdrant simultaneously.
When useDualWrite is active, upsertAsset updates the embedding_vector in Supabase and also performs a qdrantClient.upsert to the target collection.
For searching, the service can fallback to Supabase's match_documents RPC if Qdrant is not enabled.
```
// Example usage of VectorSyncService logic
// If USE_QDRANT=true and DUAL_WRITE_VECTORS=true, both stores are updated.
await vectorSyncService.upsertAsset(asset);

// Search logic switches between Qdrant and Supabase RPC based on USE_QDRANT
const results = await vectorSyncService.searchSimilar(query, 'assets');
```
https://github.com/kronova-intelligent-systems/asset-intel-orchestration-engine/blob/main/docs/KRONOVA_VECTORIZATION_MIGRATION_PLAN.md

Kronova Asset Intelligence Platform

What's inside Kronova

Custom OAuth 2.1 (Self-Managed)

Supabase Native OAuth 2.1 (Managed)

Use Supabase Native OAuth 2.1 (Recommended) if:

Use Custom OAuth 2.1 if: