DARSHAN GAIKWAD
PUNE, INDIA · AI-NATIVE SYSTEMS THINKER & BUILDER

AI-native systems thinker and builder.

I think in systems, learn from the docs, orchestrate the build, and ship the result.

AXIOM:Architecture > Systems > Optimization >> Code
“I don't need to know everything before I start building. I need to know how to figure things out.”
View selected workGet in touch
DARSHAN// Latin
Latin
DARSHAN
// Darshan
VERIFIED RECORD
2026
B.E. Electronics & Telecom
PCCOER, Pune
Inspect
2×
Govt. of India Copyrights
Government of India Copyrights
Inspect
Amazon
ML Summer School Scholar
Pan-India Selection
Inspect
Solana
Solana School (Fall 2026)
Developer Cohort
Inspect
SYSTEMS CATALOGUE

The evolution of the thinking.

Hardware → Machine Learning → Infrastructure → Web3 & Solana → Autonomous Systems → Future Worlds. A transparent chronicle of what was built, what was learned, and what shipped.

NARRATIVE PROGRESSION // VERIFIABLE EXECUTIONHuman Work → Guarded Action → Autonomous Audit
01Proof of Work

PROVN

“Can human developer contributions be independently verified and anchored without platform mercy?”

Human Work → Cryptographic Evidence → On-Chain Reputation
02Guarded Autonomous Action

SENTINEL FINANCE

“Can an AI agent make financial decisions while on-chain postconditions guarantee user constraints?”

AI Decision → Constraint Enforcement → Guarded Devnet Settlement
03Proof of Agent Action

AGENT VERIFICATION

“How do we prove what an autonomous agent did, under whose authority, and whether policy was respected?”

Agent Execution → Canonical Envelope → Non-Repudiable Receipt
[ CURRENT SYSTEMS & RESEARCH ]Independent builds, active experiments, and architectures evolving around verifiable autonomous systems
BUILT · CURRENT
Live AppCode
01 // Solana-Native Cryptographic Provenance Protocol

PROVN

“What if your work history could be independently verified without platform mercy?”

1. What was the question?

Developer work and agent executions are scattered across PRs, private tools, and fragile platforms. Resumes can be fabricated or deleted. Can we turn contributions into immutable, self-sovereign evidence envelopes signed with a keypair?

2. What did I have to learn?

Solana account structures, Anchor specifications, Ed25519 signature mechanics, Arweave transaction tagging via Irys, Row-Level Security in Postgres, and threat modeling for anti-replay verification gates.

3. How did the system work?

Users or agents sign canonical JSON work envelopes with Ed25519 keypairs. An API gateway enforces a ±15-minute anti-replay sliding window. Evidence envelopes are permanently archived to Arweave via Irys, and immutable commitments are anchored to deterministic Solana PDAs [b'proof', authority, proof_id].

4. What actually shipped?

A live, running protocol on Solana Devnet and Irys, 294 air-gapped cryptographic unit tests, 304 passing CI tests, a live verifier inspector, dynamic SVG proof passports, and protection against 5 active threat vectors documented in the Litepaper.

PROVN · PROVENANCE EXECUTION PIPELINE

STAGE 1 OF 5
001
Sign with Keypair
Cryptographic origin
002
Anti-Replay Verification
Replay defense
003
Arweave Permanent Storage
Data availability
004
Anchor PDA Commitment
On-chain settlement
005
Independent Verifier
Public verification
STAGE 001 // Sign with Keypair

Author signs canonical work envelope with Ed25519 keypair, binding identity to contribution.

294 offline tests covering signature tampering, challenge expiration, and replay defense
Deterministic PDA derivations [b'proof', authority, proof_id]
Permanent decentralized archival via Irys and Arweave L1
SIWS OAuth binding GitHub identities to Solana wallet keypairs
Primitives:SolanaAnchor (Building & Learning)RustEd25519Irys / ArweaveNext.jsPostgres RLS
BUILT · STOCKLANA HACKATHON · 2026
Code
02 // Autonomous Financial Agent Execution & Policy Guardrails on Solana

SENTINEL FINANCE

“What if an AI agent could make the decision — but could never settle an outcome that violated the user's rules?”

1. What was the question?

When an investor delegates portfolio management to an autonomous agent, authorization alone is not enough. The agent can be allowed to trade. But what guarantees that the resulting financial state still satisfies the investor's rules? Sentinel explores a stricter model: The agent can decide. The protocol decides whether the resulting state is allowed to settle.

2. What did I have to learn?

Anchor program architecture, Solana account and state modeling, on-chain policy enforcement, financial invariant checks, fixed-point financial math, Pyth price feed consumption, Meteora DBC execution adapters, autonomous agent loop orchestration, and PROVN evidence commitments.

3. How did the system work?

The agent proposes a trade. Sentinel evaluates whether the resulting financial state violates defined constraints: maximum single-asset exposure, minimum stablecoin reserve, maximum trade size, slippage bounds, and pre-IPO allocation ceilings. The Anchor program's `execute_guarded_trade` instruction is the authoritative enforcement boundary: if compliant, it settles; if non-compliant, it atomically reverts. All executions generate PROVN cryptographic evidence envelopes.

4. What actually shipped?

A working Stocklana hackathon prototype with a live Solana Devnet Anchor program, policy engine, autonomous robo-agent loop, execution adapters (Meteora, PreStocks), and PROVN evidence integration. The repository explicitly distinguishes between verified on-chain code, cryptographic engines, and simulated execution.

SENTINEL FINANCE · FLAGSHIP FIVE-STEP GUARDED DEMO

STAGE 1 OF 5
001
Connect & Set Constraints
Policy boundary
002
Agent Proposes Violating Trade
Autonomous decision
003
Sentinel Rejects & Reverts
On-chain revert
004
Agent Adapts Strategy
Adaptive loop
005
Compliant Trade Settles
Guaranteed settlement
STAGE 001 // Connect & Set Constraints

Investor defines strict vault invariants: max 25% single-asset exposure, min 30% stablecoin reserve.

On-chain postcondition enforcement via Anchor execute_guarded_trade instruction
Deterministic financial invariant validation (exposure caps, reserve floors, slippage bounds)
Integrated Pyth network price feeds and Meteora dynamic bonding curve adapter
Direct bridge between autonomous decision-making and verifiable cryptographic proofs
Primitives:Solana DevnetAnchor ProgramRustPythonPyth OracleMeteora DBCPROVN Receipts
[ BUILT · FOUNDATIONS ]Physical single-board infrastructure and peer-reviewed machine learning research
BUILT · 2025 · 3RD YEAR MINI PROJECT
03 // Self-Hosted Microservices & Private Cloud Architecture

Raspberry Pi Private Cloud NAS

“I wanted my own cloud.”

1. What was the question?

Why depend on centralized commercial cloud storage when you can build and operate your own miniature private cloud with containerized services and remote networking?

2. What did I have to learn?

Linux system administration from scratch, systemd services, Docker container orchestration, reverse tunneling (ngrok), local area network routing, file-system permissions, and physical thermal constraints on ARM SBC hardware.

3. How did the system work?

The Raspberry Pi acted as a physical host running a customized Linux OS. Docker containerized independent microservices and storage daemons. An ngrok tunnel provided secure, encrypted remote access from outside the local network without exposing raw router ports.

4. What actually shipped?

A continuously operating physical home server providing personal file storage, remote media streaming, and isolated service containers accessible from any device over the internet.

Hands-on mastery of Linux permissions, ARM architectures, and networking protocols
Operated as a functional personal daily driver for remote file synchronization
Containerized independent microservices with secure reverse tunneling via ngrok
Primitives:Raspberry PiLinux (Debian)DockerDocker ComposengrokNetworkingBash
BUILT · 2026 · FINAL YEAR MAJOR PROJECT
Accepted with minor revisions at ICAIMEST · Govt. of India Copyright
04 // Deep Learning Pipeline for Spatiotemporal Video Restoration

HPURN — AI-Based Video Dehazing

“What happens when image restoration has to work across time, not just individual frames?”

1. What was the question?

Single-image dehazing methods flicker and fail when applied to continuous video streams. How do we preserve temporal consistency across frames while removing non-uniform haze?

2. What did I have to learn?

Atmospheric scattering models, Dark Channel Prior mathematics, ConvLSTM recurrent spatiotemporal architectures, and adversarial loss formulations in CycleGAN.

3. How did the system work?

Combined a physics-based Dark Channel Prior (DCP) with an AOD-Net transmission estimator, passed recurrent features through ConvLSTM to enforce inter-frame smoothness, and refined visual quality using CycleGAN unpaired adversarial translation.

4. What actually shipped?

A complete research pipeline evaluated on the RESIDE-6k benchmark dataset. Research paper accepted with minor revisions at ICAIMEST and registered under Government of India Copyright.

Government of India Copyright registered
Academic paper accepted with minor revisions at ICAIMEST
Combined classical physics-based optics (DCP) with modern deep recurrent networks
Rigorous empirical evaluation against standard computer vision benchmarks (RESIDE-6k)
Primitives:PythonPyTorchCycleGANConvLSTMDark Channel PriorRESIDE-6k
[ EXPERIMENTED ]Rapid prototyping under hackathon constraints · Speed & tool orchestration
EXPERIMENTED · HACKATHON PROTOTYPE
Live AppCode
05 // Autonomous Agent Evolution Engine

FORGE

“A few-hour hackathon experiment in autonomous agent engineering.”

1. What was the question?

Agents break when they hit unexpected API constraints. Can an agent treat its own runtime failures as training signals and mutate its own prompts and tool playbooks?

2. What did I have to learn?

How to quickly structure a dual-loop reflection system during a compressed hackathon window using Agent Orchestrator (AO) and FastAPI.

3. How did the system work?

An Inner Loop catches tool errors and caches successful playbooks. An Outer Loop clusters benchmark failures and passes architectural mutations through a Pareto Acceptance Gate.

4. What actually shipped?

A working prototype with a live interactive web dashboard, FastAPI service, and empirical test bench demonstrating a 75% latency reduction on repeat warm runs.

Built rapidly during a hackathon to test agent adaptation mechanics
Demonstrates speed, experimentation, and AI-assisted prototyping
Measured empirical gains: -66.7% tool calls, -75% latency, 100% accuracy on warm repeat runs
Primitives:PythonFastAPINext.jsAgent OrchestratorPostgreSQL
[ BUILDING / EXPLORING ]Active research specifications, receipt structures, and policy gates
BUILDING / EXPLORING
06 // Cryptographic Audit Receipts & Policy Gates for Autonomous Agents

Agent Verification Layer

“Can autonomous software actions themselves be proven?”

1. What was the question?

As autonomous agents execute code changes, API calls, and x402 payments, organizations need non-repudiable receipts. How do we verify agent behavior without human bottlenecks?

2. What did I have to learn?

Researching cryptographic receipt structures, delegation mechanisms, policy enforcement schemas, and Solana micro-payment state models.

3. How did the system work?

Agents generate structured execution traces signed with dedicated Ed25519 keypairs, verified against deterministic policy gates, and anchored on-chain for dispute resolution.

4. What actually shipped?

Active architectural specifications, threat models, and receipt prototypes evolving directly out of the PROVN cryptographic core.

Natural evolution from human proof-of-work (PROVN) and guarded action (Sentinel) to autonomous proof-of-action
Focuses on verifiable receipts and policy enforcement for AI systems that execute money and code
Primitives:SolanaEd25519x402 PaymentsAgent KeypairsAnchor
[ LONG-TERM RESEARCH THESIS ]Deep intellectual inquiry into autonomous character societies and cultural provenance
LONG-TERM RESEARCH THESIS
07 // Research Exploration in Autonomous Living Worlds

Civilization Engine & Cultural Ledger

“A question I'm obsessed with: What happens when generative worlds can remember, evolve, and create their own cultural continuity?”

1. What was the question?

Current virtual worlds are static scripts. Generative AI creates disconnected content while scraping cultural heritage without attribution. Can we model autonomous societies that evolve lore and record cultural assets on an open ledger?

2. What did I have to learn?

Researching emergent narrative graphs, procedural world generation, agent social memory indexing, cultural attribution frameworks, and decentralized state compression.

3. How did the system work?

A decoupled 5-tier architecture: (1) World Substrate, (2) Cultural Ledger for cryptographic attribution, (3) Character Consciousness, (4) Civilization Memory, and (5) Narrative Intelligence.

4. What actually shipped?

Not a finished company or commercial startup — this is an intellectual research specification, conceptual framework, and active design exploration.

Explores cultural provenance and micro-royalties inside generative worlds
Conceptual architecture exploring decentralized living-world runtimes
Clear demarcation: long-term intellectual research, not an over-hyped startup claim
Primitives:Solana State CompressionVector MemoryAutonomous AgentsNarrative Graphs
AI-NATIVE ORCHESTRATION

How I actually build.

“I rarely start with how do I code this? I start with what is the system? Then I read. I go through documentation, repositories, specifications, and examples until I understand enough to make architectural decisions. AI handles a large part of the implementation acceleration. I orchestrate it, review it, test it, and keep pulling the system toward the thing I actually wanted to build.”

THE CORE DISTINCTION

AI accelerates implementation. It does not replace understanding.

AI writes code fast, but code is just the final artifact. The leverage comes from orchestrating the system boundaries and catching errors before they compound.

SYSTEM BOUNDARIES

Knowing what to build, why to build it, and how the pieces fit together.

VERIFICATION GATES

Identifying dangerous assumptions and testing what the docs actually state.

ERROR DETECTION

Spotting when an AI-generated implementation is subtly wrong or insecure.

DECOMPOSITION

Decomposing a vague, ambitious idea into structured, executable work units.

THE REPEATABLE FEEDBACK LOOP: QUESTION ↓ RESEARCH ↓ ARCHITECTURE ↓ ORCHESTRATE ↓ VERIFY ↓ SHIP
01STAGE 01

Question

What is the actual system we need?

I rarely start with 'how do I code this?' I start with 'what is the system?' Identify what problem needs solving and what constraints cannot be violated.

02STAGE 02

Research & Documentation

What does the documentation actually say?

I read. I go through documentation, specifications, open-source repositories, and technical examples until I understand enough of the underlying mechanics to make architectural choices.

03STAGE 03

System Design

How do the primitives connect?

Map out the data flow, state machines, trust boundaries, and failure modes. Decompose a vague, ambitious idea into concrete, executable components.

04STAGE 04

AI-Assisted Build

How do we orchestrate implementation rapidly?

I give detailed instructions to coding agents (Claude, Antigravity, Gemini). AI handles a large part of the implementation acceleration while I guide the trajectory.

05STAGE 05

Verify & Challenge

Where is the generated code wrong?

Review the implementation, write tests, inspect edge cases, check anti-replay windows, and test against real APIs. Find where the AI or assumptions failed.

06STAGE 06

Ship & Iterate

Is it running and verified in the real world?

Deploy the system, observe real behavior, and continuously pull the software toward the thing I actually set out to build.

THE STORY

Curiosity, documentation & leverage.

“I tend to ask questions that eventually become engineering problems.”

I started with electronics.

Then I got obsessed with machine learning.

Then I built my own little cloud on a Raspberry Pi.

Then I fell down the Solana rabbit hole.

Now AI lets me explore systems far outside the boundaries of what I could comfortably build alone.

I spend a lot of time reading documentation, figuring out unfamiliar systems, designing architectures, and orchestrating AI tools to turn those ideas into working software.

I'm still learning a lot. That's kind of the point.

CORE OPERATING AXIOM
Architecture > Systems > Optimization >> Code
“I don't need to know everything before I start building. I need to know how to figure things out.”
THE 6-PHASE CAREER ARC: HARDWARE → ML → INFRASTRUCTURE → WEB3 → AI-NATIVE → AUTONOMOUS SYSTEMS
PHASE 1Hardware & Physical Constraints
Electronics & Telecommunication Engineering (PCCOER)
PHASE 2Machine Learning & Image Restoration
HPURN Neural Dehazing & Academic Research
PHASE 3Self-Hosted Infrastructure
Raspberry Pi Private Cloud NAS
PHASE 4Web3 & Decentralized Primitives
Solana, Cryptography & Verifiable State
PHASE 5AI-Native Engineering
The Implementation Multiplier
PHASE 6Autonomous & Verifiable Systems
PROVN → Sentinel Finance → Agent Verification
PHASE 1 // Hardware & Physical ConstraintsPhysical constraints, embedded control, hardware feedback loops
Electronics & Telecommunication Engineering (PCCOER)

Working with microcontrollers, sensor telemetry, and circuits taught me that software is only one component of a larger system. Memory, clock cycles, voltage drops, and noisy inputs cannot be hand-waved away.

Primitives & Technologies:
ESP8266ArduinoEmbedded C++SensorsHardware Constraints
FORMAL ENGINEERING DEGREE

B.E. Electronics & Telecommunication Engineering

PCCOER, Pune · Savitribai Phule Pune University · 2026

Rigorous grounding in signal processing, electromagnetic fundamentals, embedded architectures, control systems, and computational algorithms.

COMPETITIVE FELLOWSHIPS
Amazon ML Summer School
Deep learning & applied representations
SCHOLAR
Solana School (Fall 2026)
Anchor, Rust, PDAs, & Solana runtime
COHORT
CAPABILITIES INDEX

Systems, software & primitives.

A concise index of working technical domains, engineering skills, and architectural tools.

SYSTEMS01
  • System Architecture
  • Problem Decomposition
  • Trust Boundaries
  • Threat Modeling
Primitives:
State MachinesInvariant ValidationData Flow Isolation
AI & AGENTS02
  • Machine Learning
  • Autonomous Agents
  • AI Build Loops
  • Benchmark Evaluation
Primitives:
PyTorchCycleGANConvLSTMAgent Orchestrator
WEB3 & SOLANA03
  • Solana Runtime
  • Anchor Framework
  • Rust Smart Contracts
  • Cryptographic Primitives
Primitives:
PDAsEd25519 SignaturesIrys / Arweave L1Pyth Price Feeds
INFRASTRUCTURE04
  • Docker & Compose
  • Linux (Debian)
  • Networking & Tunnels
  • Postgres (RLS)
Primitives:
Systemd Daemonsngrok Reverse TunnelsFastAPINext.js / TypeScript
HARDWARE05
  • Raspberry Pi
  • Arduino
  • ESP8266
  • Embedded C++
Primitives:
Physical ConstraintsSensor TelemetryARM Single-Board Computers
ACTIVE RESEARCH PROGRAMS

Ideas & Lab Notes.

Two active research programs exploring verifiable autonomous systems, living worlds, and decentralized cultural infrastructure.

PROGRAM // 01
BUILDING

Agent Verification Layer & x402 Audit Infrastructure

A verifiable audit and receipt protocol for autonomous AI agent executions, tool calls, and HTTP 402 machine-to-machine payment settlements.

Core Thesis

“As software agents gain authority to deploy capital, invoke external APIs, and execute trades, auditability cannot rely on centralized server logs. Agents must sign canonical execution traces with dedicated Ed25519 keypairs. Incorporating deterministic replay defense, sliding observation windows, and on-chain Anchor commitments ensures that machine-to-machine settlements and tool executions remain non-repudiable and bound to human policy.”

Sub-Inquiries Under Investigation:
Authority Policies: Binding autonomous agent runtimes to on-chain constraint boundaries (exposure caps, trade ceilings, revert conditions).
Deterministic Replay Defense: Preventing adversarial trace reuse and timestamp manipulation across distributed execution nodes.
Machine-to-Machine Settlement: Enabling sub-cent Solana payment channels for autonomous API and tool-use monetization.
Cryptographic & Network Primitives:
Ed25519 Agent Keypairsx402 Payment ReceiptsAnchor PDA CommitmentsDeterministic Replay DefenseMachine-to-Machine Settlement
PROGRAM // 02
RESEARCH

Cultural Ledger & Living-World Substrates

Decentralized simulation substrates and on-chain attribution mechanisms for persistent agent societies, living lore, and cultural heritage.

Core Thesis

“Generative world models and autonomous agents extract folklore, aesthetic traditions, and narrative motifs without attribution or memory. The Cultural Ledger explores whether cultural heritage can be cryptographically registered on Solana, allowing living worlds to simulate persistent agent societies with evolving societal memory while routing autonomous micro-royalties back to origin traditions.”

Sub-Inquiries Under Investigation:
Attribution Trees: Using Solana state compression to register folklore, narrative motifs, and cultural DNA with minimal on-chain rent.
Living-World Runtimes: Simulating non-deterministic agent societies with persistent memory and emergent historical lore.
Verifiable Reputation Trails: Linking creative contributions, world milestones, and cultural lineage to permanent Arweave storage.
Cryptographic & Network Primitives:
Solana State CompressionProvenance TreesLiving-World RuntimesSocietal Lore GraphsVerifiable Reputation Trails
NOW
PUNE, INDIA (IST) · 2026
01 // PROVN

Refining verifiable cryptographic infrastructure, anti-replay sliding windows, and on-chain Anchor commitments on Solana Devnet & Arweave.

02 // SENTINEL FINANCE

Exploring guarded autonomous financial execution, postcondition invariants, and Pyth oracle integrations on Solana.

03 // ACTIVE RESEARCH

Formulating verifiable execution receipts, x402 payment flows, and authority policies for autonomous AI agents.

04 // SOLANA SCHOOL

Selected for Solana School (Fall 2026) mastering Anchor, Rust contracts, and PDA security.

GET IN TOUCH

Have an unconventional idea?
Let's build the system behind it.

I focus on autonomous AI agent coordination, cryptographic proof systems, Solana runtime primitives, and living-world architectures. Open to interesting engineering problems, collaborations, and remote Web3 / AI infrastructure roles.

Direct Email
darshangaikwad712@gmail.com
Compose
Direct Contact / Call
+91 8766895053
Call
github.com/dren712LinkedIn@DarshanVG712
Send a Message