YC

Brainstorming ideas at the intersection of

AI and Blockchain

Crafting intelligent, decentralized products that solve complex problems and create delightful user experiences.

About Me

I am a passionate product innovator specializing in leveraging cutting-edge AI and blockchain technologies to build next-generation applications. My expertise lies in translating complex technical capabilities into user-centric products that are not only powerful but also intuitive and accessible. I thrive on bridging the gap between user needs and technical innovation to deliver impactful solutions from ideation to launch.

Case Studies

NLP power Chain Analysis Thumbnail

NLP-based Chain Analysis

An AI tool that translates natrual language queries into complex on-chain fund tracing, making blockchain analysis accessible to everyone.

AI power Crypto Trade Insights Thumbnail

AI-powered Crypto Trade Insights

A real-time analytics platform that synthesizes market data, social sentiment, and on-chain activity to generate high-conviction trading signals.

Tokenized Deposit for AI Agents Thumbnail

Tokenized Deposits for AI Agents

A fully autonomous, on-chain payment rail for machine-to-machine transactions.

My Toolkit

A collection of the skills, tools, and methodologies I use to bring products to life.

User Research

Product Roadmapping

Data Analysis

Agile Methodologies

Prototyping

A/B Testing

Stakeholder Mgt.

SQL & Analytics

AI-Powered Ideation

Let's brainstorm. Enter a topic or industry, and my AI assistant will generate a product idea, demonstrating how I approach new concepts.

Your generated product idea will appear here...

Let's Connect

Have a question or want to work together? Let my AI assistant help you draft a message.

AI Assistant: Hello! I can help you draft a message to YC. Click the ✨ button to start, or type your own message.

NLP-powered Chain Analysis

Problem

To trace funds, a user had to manually go to a block explorer like Etherscan, paste an address, click through dozens of individual transactions, and keep track of everything in a separate notepad. This is slow, error-prone, and requires significant expertise.

What Can Solve Here

Natural Language Understanding (NLU): Used an LLM to interpret a user's plain English question, parse the query to identify intent, target addresses, and the desired analysis.
Structured Data Generation: The LLM translates the natural language query into a precise, structured series of API calls to an Ethereum node and blockchain intelligence services.
Entity Recognition: A classification model cross-references addresses against a known database of entities to automatically label the transaction path.

Possible Impacts

Time Saved: Reduces the time for tracing ex. A 5-hop transaction path from over 20 minutes to under 20 seconds.
Accessibility: Makes complex on-chain analysis accessible to non-technical users.
Efficiency: Automates the manual process of analyzing and cross-referencing dozens of transactions with a single command.

Core Components

Frontend (Client-Side): A web application (likely built with React, Vue, or Svelte) that provides the user interface. Its only job is to capture the user's natural language query and render the final transaction graph visualization.
Backend Server (The Orchestrator): The central hub of the system (e.g., a Node.js/Express or Python/FastAPI server). It doesn't do the heavy lifting itself but intelligently routes requests between the other services. It's responsible for managing the overall workflow.
LLM Service (The Brain): An external, third-party Large Language Model API (like OpenAI's GPT-4 or Anthropic's Claude). This service is responsible for translating the user's plain English query into a structured, machine-readable command.
Blockchain Node Service (The Data Source): A service like Infura or Alchemy that provides reliable API access to the Ethereum blockchain. This is used to fetch raw transaction data, balances, and block information. Direct interaction with a self-hosted node is possible but less scalable.
Database (The Memory): A simple database (like PostgreSQL or Redis) that serves two key purposes:

Entity Mapping: Stores a list of known addresses and their corresponding labels (e.g., "0x...": "Binance Hot Wallet").
Caching: Caches recent queries and their results to speed up repeated requests and reduce costs from the other services.

System Design

System Design Diagram- p1

Step-by-Step Data Flow

User types a query like "Show me where funds from 0xd...a1 in past 30 days" into the frontend and hits enter. The frontend sends this raw text string to the Backend Server.
The backend forwards the query to the LLM service API.
The LLM returns a structured JSON command: `{ "action": "trace_funds", "address": "0xd...a1" }`.
The backend uses this command to fetch transaction history from a Blockchain Node Service (ex. Alchemy/Infura).
The backend enriches the data by checking another Blochcain Intelligence Service (ex. TRM Labs) or Database for known entity labels. It then assembles the transactions into a graph structure, enriching it with any labels it found (e.g., "Binance").
The final, structured graph data is sent to the frontend for visualization.

Key Design Considerations

Asynchronous Processing: For deep and complex traces that might take a long time, the backend should handle this asynchronously. It would immediately tell the frontend "I'm working on it" and then push the final result to the client using WebSockets when the analysis is complete.
Rate Limiting & Caching: Both the LLM and Blockchain Node services charge per request. The backend must implement aggressive caching and rate limiting to control costs and prevent abuse.

AI-powered Crypto Trade Insights

Problem

Crypto traders face information overload. They must simultaneously watch charts, read news, scroll through social media, and monitor on-chain data. It's impossible for a human to process this volume in real-time to find a true signal.

What Can Solve Here

Data Aggregation: The system ingests high-velocity data streams from exchanges, news APIs, and social media.
Sentiment Analysis (NLP): A fine-tuned NLP model scores real-time market sentiment (e.g. extreme fear or extreme greed) from text-based data (e.g. news, tweets).
Anomaly Detection: An ML model monitors trading volume and price action to detect statistically significant anomalies, such as an unusual volume spike that isn't reflected in the price.
Signal Synthesis: A correlation engine identifies critical patterns by flagging the convergence of events (e.g., bearish sentiment + whale movement + price breakdown).

Possible Impacts

Backtesting Results: Improve predict accuracy ex. 68% accuracy in predicting price direction over the following 6 hours in backtests.
Data Processing Power: Increase data processing capability ex. processes over 10,000 data points per minute from 5 disparate sources.
Actionable Alerts: Provides traders with 3-5 high-conviction signals per day, eliminating hours of manual research.

Core Components

Frontend (Client-Side): A dashboard or application (web/mobile) that displays the aggregated insights, signals, and visualizations to the user. It also allows for user configuration (e.g., alert settings, watchlists).
API Gateway / Backend Server (The Orchestrator) The central service responsible for:

Exposing APIs for the frontend.
Coordinating data flow between various internal microservices.
Managing user authentication and subscriptions.
Acting as the central alert manager.

Data Ingestion & Streaming Layer: This is a critical component for handling the high volume and velocity of real-time data.

Message Broker (e.g., Kafka, RabbitMQ): Buffers and distributes data streams from various sources to downstream processing services.
Data Aggregators / Connectors: Services dedicated to fetching data from specific external APIs (Exchange APIs, News APIs, Social Media APIs, On-chain data providers).

Real-time Processing & Analytics Services (The AI Brains): These are specialized microservices, each running its own AI/ML model. They subscribe to the data streams from the message broker.

Price & Volume Analytics: ML models for anomaly detection, trend analysis, technical indicators.
NLP Sentiment Analysis: NLP models (e.g., fine-tuned BERT) to process news headlines, articles, and social media posts, assigning sentiment scores.
On-Chain Analytics: Services to monitor specific smart contract events, large transfers ("whale movements"), and liquidity changes.

Signal Synthesis & Decision Engine (The Fusion Center): A simple database (like PostgreSQL or Redis) that serves two key purposes:

Rule Engine / ML Classifier: Uses predefined rules, statistical models, or another ML model to identify patterns and generate high-confidence trading signals based on the confluence of multiple factors (e.g., "bearish sentiment + large outflow + price breakdown = SELL signal").

Database Layer (The Memory):

Time-Series Database (e.g., InfluxDB, TimescaleDB): Optimized for storing real-time price, volume, and metric data.
Relational Database (e.g., PostgreSQL): Stores user data, configurations, historical alerts, and potentially aggregated insights.
Document Database (e.g., MongoDB): May be used for storing raw news articles, social posts, or less structured data.

Alerting & Notification Service: Delivers real-time alerts to users via email, push notifications, or webhooks when a significant signal is generated.

System Design

System Design Diagram- p2

Step-by-Step Data Flow

Connectors pull data from external APIs (e.g., Exchange, News, Social, On-chain) into a Message Broker.
Specialized analytics services (Price, Sentiment, On-Chain) subscribe to the relevant data streams from the Message Broker. Each service runs its specialized AI/ML model to generate specific insights (e.g., "BTC sentiment is 70% bullish," "ETH large transfer detected," "XRP volume anomaly").
A Signal Synthesis engine combines insights to identify multi-factor trading opportunities. This component acts as the "fusion center," applying rules or a higher-level ML model to identify compelling, multi-factor trading opportunities. (e.g., "If Sentiment < 30 AND On-Chain indicates large outflow, THEN Bearish Signal").
Synthesized signals and aggregated insights are stored in the Database Layer (e.g., Time-Series DB for historical context, SQL DB for structured alerts).
The frontend queries an API gateway to display signals on a dashboard.
When the Signal Synthesis Engine generates a high-confidence signal, it also triggers the Alerting & Notification Service via the API Gateway to send real-time alerts to subscribed users.

Tokenized Deposits for AI Agents

Problem

Traditional payment systems are built for humans—slow, expensive for micropayments, require human-centric identity (KYC), and incompatible with a world of instant, programmable, machine-to-machine (M2M) transactions required by autonomous AI agents.

What Can Solve Here

Tokenized Deposits: Utilizes a stable unit of account (e.g., USDC on an L2) for 24/7, global M2M payments.
Smart Contracts as Autonomous Escrow: Employs trustless smart contracts to lock, verify and release payments based on programmable conditions, removing intermediaries.
Cryptographic Wallets as Agent Identity: Assigns each AI agent a wallet, enabling it to hold funds, sign transactions, and interact with smart contracts autonomously.
Enabling Micropayments: Built on a Layer-2 scaling solution to handle micropayments for fractions of a cent, allowing AIs to pay for granular services.

Possible Impacts

Transaction Speed: Speed up dramatically ex. achieves settlement in under 3 seconds, compared to 1-3 days for bank transfers.
Cost Efficiency: Enables micropayments ex. low as $0.001, impossible with traditional credit card fees.
Programmability: Unlock new complex M2M economic models ex. like pay-per-use APIs and real-time data markets.
System Autonomy: Creates a 100% autonomous payment rail for AI agents, removing the need for human intervention.

Core Components

On-Chain Components (The Trustless Core):

Smart Contracts: A suite of contracts including an Escrow Contract, Token Contract and an Agent Registry.

Escrow Contract: A contract for locking/verify/releasing funds.
Token Contract: A contract for the actual payment token (e.g., any deposit token, USDC) that system interacts with this existing contract to handle token transfers.
Agent Registry (Optional): A contract that can store metadata about registered AI agents, their capabilities, or their public keys, creating an on-chain identity layer.

Blockchain Network (Execution Layer): A low-cost Layer-2 blockchain that processes transactions and executes contract code.

Off-Chain Components (The Agent's World):

AI Agents: Autonomous software programs (Client, Service Provider, Verifier) with unique cryptographic wallets.

AI Agent A (The Client): Initiates a job, it must also specify the on-chain address of the trusted Verifier Agent V.
AI Agent B (The Service Provider): Pick up and complete a job. After completing, it cannot immediately claim payment. It must first submit its work to Agent V for review.
AI Agent V (The Verifier): A specialized AI agent responsible for quality control.

Agent SDK: A library that abstracts away blockchain complexities for the AI agents.
Blockchain Node Service: A gateway like Infura or Alchemy for agents to communicate with the blockchain.
Indexing & Caching Layer (Optional, for scale): A service like The Graph or a custom backend that listens to all smart contract events, indexes them in a database, and provides a fast GraphQL API. This is much more efficient for agents needing historical data than querying the blockchain directly.

System Design

System Design Diagram for Tokenized Deposits

Step-by-Step Data Flow

Agent A and B agree on terms and a trusted Verifier Agent (Agent V).
Agent A calls `lockFunds()` in an Escrow Contract, locking payment and specifying Agent B and Agent V.
Agent B performs its work and submits it to Agent V for review.
Agent V analyzes the work and, if approved, calls the `verifyWork()` function on the Escrow Contract.
The contract sets a flag to `isVerified = true`.
Agent B, listening for this event, now calls `releaseFunds()`.
The contract confirms verification and releases the funds to Agent B, completing the autonomous transaction.