whoisasx.agent infra / realtime systems / rust protocols0% below surface

previously: full-stack, devops, web3.currently: agent infrastructure.

Adil Shaikh

full-stack engineer with a backend and infrastructure bias

I work on agent tooling, realtime systems, API-heavy platforms, and developer workflows. The goal is simple: make the system observable, reduce unnecessary pressure, and keep the product calm under load.

GitHub Notes Resume Email
scroll slowly

[ what keeps showing up ]

The interesting work starts when the happy path is already done.

Most of my recent work lives in the unglamorous parts of products: notification delivery, session lifecycle, rate limits, cache behavior, CLI edges, dashboard state, and the exact moment a realtime interface stops feeling realtime.

  • build the thing end to end, then instrument it
  • prefer measured bottlenecks over vague scale claims
  • keep durable state small, explicit, and recoverable

[ receipts, not adjectives ]

Some numbers are useful because they explain the shape of the work.

AO API calls~92%

lower after caching, ETags, tracing, and polling consolidation

GraphQL burn~98%

reduced while moving toward larger concurrent agent sessions

AO sessions50+

practical sessions per PAT after rate-limit and lifecycle work

DSA base1000+

problems solved, LeetCode Knight, 1950+ rating

[ current surface area ]

Fewer projects. Deeper signal.

ComposioHQ · core contributor

Agent Orchestrator

I like working near the nervous system of agent products: sessions, signals, notifications, and the small state transitions that decide whether a human trusts the dashboard.

operating modemake coordination visible before it turns into chaos
  • Turned notification delivery into a full product loop: semantic payloads, routing, CLI setup, desktop/web surfaces, integrations, and smoke tests.
  • Reduced pressure at the source with tracing, ETags, caching, and polling consolidation instead of hiding the problem in UI state.
  • Spent time on the small reliability edges: liveness races, session status, dashboard child cleanup, YAML/start behavior, and listing correctness.
TypeScriptNodeNext.jsGitHub APInotifiers

aoagents · core contributor

ReverbCode

This is the part of engineering I keep coming back to: a local system that runs for a long time, owns its state clearly, and can explain what it is doing without ceremony.

operating modeprefer boring durability over clever uncertainty
  • Worked around SCM observability, provider-neutral observer flows, notification APIs, SSE clients, and delivery runtime.
  • Helped lay notification foundations for a Go daemon that supervises agent sessions without depending on browser memory.
  • Kept the backend surface intentionally explicit: readiness, graceful shutdown, PID/port handshake, SQLite records, and lifecycle cleanup.
GoCobrachiSQLiteSSEElectron

AgentGuards · infra project

Agent Guardrails Protocol

The Web3 work that interests me is not noise. It is where policy, latency, and accountability meet: can an autonomous agent be watched, judged, and stopped fast enough?

operating modetreat protocols as enforcement surfaces, not slogans
  • Used Anchor/Rust, Helius webhooks, a Claude judge, and SSE to connect off-chain observation with on-chain action.
  • Designed for fast policy response, including suspicious-agent pause paths under three seconds.
  • Kept the framing practical: threat monitoring, guardrails, and realtime visibility before speculation.
RustAnchorSolanaHeliusSSE

whoisasx · product proof

Canvora

Realtime interfaces are psychological before they are technical. If cursors lag, undo feels unsafe, or state jumps, people stop trusting the room.

operating modemake collaboration feel quiet, stable, and shared
  • Built around WebSockets, stable sync, PostgreSQL-backed state, and practical drawing flows instead of feature theatre.
  • Tracked the experience through latency and concurrency: under 300ms for 95% sessions and support for 1,000+ concurrent users.
  • Kept this as the main older product because it explains a recurring bias: systems are only good when users can feel the stability.
Next.jsWebSocketsPostgreSQLPrismaDocker

[ writing ]

Engineering notes, deep dives, and change logs.

My writing is mostly implementation reports: what broke, what changed, which tradeoffs were real, and how the final system behaved.

12 min · ao / notifications / integrations

AO Notifications System - Implementation Report

Architecture notes for semantic payloads, routing presets, notification center, desktop delivery, Slack, Discord, Gmail, Composio, OpenClaw, webhooks, setup, and smoke tests.

read note 25 min · github / api / performance

GitHub API Rate Limiting - Complete Change Log

A changelog-style deep dive through REST vs GraphQL pressure, JSONL tracing, ETags, cache design, lifecycle polling, dashboard dedupe, and session-scale constraints.

read note

[ stack and path ]

Tools change. The bias stays: ship, measure, simplify.

systems
distributed systemsapi observabilitycachingrealtime delivery
backend
TypeScriptGoPythonFastAPINode.jsREST
data
PostgreSQLRedisSQLitePrismaSQLAlchemy
frontend
ReactNext.jsTailwindSSEWebSockets
infra
DockerGitHub ActionsNixAWSKubernetes
web3
RustSolanaAnchorHelius
2021 - 2025

B.Tech CSE, NIT Patna

Computer science base, algorithms, operating systems, OOP, and distributed systems.

2024 - 2025

Product systems

Canvora, Memora, realtime collaboration, AI search, and full-stack product loops.

2025 - 2026

Agent + Web3 infra

Solana guardrails, 100xdevs work, devops practice, and agent-safety experiments.

Mar 2026 - now

AO / ReverbCode contributor

Notifications, session lifecycle, API pressure, SCM observability, and local daemon reliability.

[ bottom of the page ]

Still around. Still building.

I am most interested in agent infrastructure, reliable developer tooling, realtime systems, and products where the backend has to quietly do the right thing.

currently exploring

letting two difficult directions breathe

one pulls me toward how intelligence forms from first principles; the other toward markets where time, memory, and decision-making become almost the same thing.

depthML coremodels, math, training loops, and the parts hidden below APIs
latencyC++ exchangesmatching engines, memory, cache lines, and time as a budget
emailadilshaikh4064@gmail.comgithub@whoisasxlinkedin/in/adilshaikh4064leetcode1950+ ratingx@whoisasxbaseNoida · Hyderabad · Mumbai · Patna

made with Next.js · refreshed for 2026 · whoisasx