Srijan Srivastava

Product engineer.

I build products that use agents: retrieval, tool calls, and the parts that keep the system readable when it acts on its own.

GitHub

Tools made producing something cheap; what stayed scarce is judgment and care. I use the fast tools, agents included, and spend the time they save on the parts that make software trustworthy. I work in domains where “fluent but wrong” is a failure, especially once a system starts acting without a human in every step.

Crediflow AI · Agentic commercial lending

Product engineer on a commercial lending console. Over ~12 sprints I shipped work across roughly 7 major feature areas along the lifecycle below. Employer work, with a small team.

Intake → Screen → Docs → Underwrite → Memo → Approve → Close → Monitor → Portfolio → Assistant

Case study: Credit Memo

Most of my depth went into the underwriting memo builder: product flow, section-level tools, generation, and structured editing. It coordinates ~16 LangChain agents. The memo feeds a real underwriting decision, so retrieval is scoped by section, claims stay tied to source documents, and low-confidence or partial filings have to fail loudly instead of inventing fields.

The specific: broad retrieval grouping kept pulling context from the wrong section of a filing. I split the retrieval categories so each memo section only sees the evidence it should cite.

The tradeoff: customers were pasting generated memos into Google Docs or ChatGPT to restyle or rewrite, which meant the feature was unfinished. Univer gave an instant Docs feel with almost no code, but no structure. Tiptap needed a custom toolbar and stored every section as structured data, so you could regenerate one section by prompt without flattening the whole memo. I chose Tiptap, even though it was slower, because conversational reruns and later editing would not get blocked.

Credit memo section-scoped regeneration A memo document holds three sections: financial analysis, facility request, and risks. The facility request section is regenerated independently by AI tools using retrieval scoped to just that section, while the other two sections stay untouched. Memo Financial analysis Facility request Risks AI tools + scoped retrieval Regenerated alone

LangChainPythonNext.jsTypeScriptPostgresRAG

Agent session observability

Active prototype. Agents can write code. What they changed, where they struggled, where someone stepped in, which mistakes keep coming back, and whether more autonomy helped: those still have to stay readable to a human. I am building an HTML session report that turns a coding-agent run into something you can actually read, with sticky metrics, intervention analysis, and notes for the next session.

The specific: a longer trace is not the useful output. A session model is: intervention points, tool usage, iteration count, and what to change before the next run.

Agent session observability feedback loop A prompt leads to agent execution, which produces tool calls, edits, and human interventions. Those events are modeled as a session, rendered as a human-readable report, and fed back as improvements for the next session. Prompt Agent run tools / edits Interventions human + retries Session model Report readable Next-session improvements

session analysisHTML reporthuman-in-the-loop

LawIndex

Experimental search over Indian central legislation from India Code. Retrieval across Acts and provisions, a RAG answer layer with citations, running on a small local model (Qwen 3.5 4B). I am trying to make that small model useful in a domain where wrong answers matter, by giving it the right evidence and limiting what it is allowed to claim. Still working on retrieval quality and answer precision; looking at retriever training next.

RAGcitationsQwen 3.5 4Bretrieval

Graphify / Graphide

Making agent-built software easier to understand: codebase knowledge graphs, how pieces relate, and feature maps of what the product actually does. Graphify turns repositories into queryable graphs. Graphide is an IDE surface on that graph, so a human and a coding agent can share the same map of the system.

knowledge graphsfeature mapsagent legibility

Remote vending · Wendor

I built the software that connects a paid web transaction to a physical vending machine, and the ESP32 firmware that ran the commands: web app, payments, messaging, and the device.

The specific: payment success is not dispense success. Retries and delayed responses force that split. I designed for exactly-once: an idempotent, retry-safe Amazon SQS queue with JWT auth and refund-on-expiry, so every transaction lands in one defined outcome when a machine or the network fails.

The tradeoff: trusting the payment webhook alone was cheaper to ship. Any timeout could leave a transaction stuck between paid and dispensed, or dispense twice. The queue cost more upfront, and it never leaves that state. I also shipped multicore ESP32 firmware (MQTT/UART) and a widget-based kiosk redesign (32 → 150+ customization options, ~12% engagement lift).

Wendor payment-to-dispense flow A confirmed payment enters a durable vend queue, which sends a dispense command to the machine. On acknowledgment it reaches a dispensed state; on no acknowledgment it retries until an expiry window closes, then reaches a refunded state instead. Payment confirmed Vend queue Idempotent, durable Dispense command To machine On ack Dispensed On expiry Refunded No ack → retry until expiry window closes

TypeScriptNestJSNext.jsAmazon SQSESP32MQTT/UART

Legal-ops retrieval · Klarity (YC S18)

Earlier retrieval work. As an Automation Architect intern I worked on document retrieval and prompt design for legal workflows: chunk optimization improved retrieval quality by 40%, and prompt libraries made outputs ~12% more consistent.

LlamaIndexFastAPIPython

Selected experiments

  • culture-sim. A simulated dish of brain cells, and tools to tell whether it behaves like a real one. Also on GitHub.
  • Needware. A demand network for unmet software needs; separates human interest, payment intent, notification intent, and builder intent instead of collapsing them into one vote.
  • srijans-agent. An agent that quietly picks up frontend work while I sleep.

What I’m thinking about

  • Where does agent autonomy start costing the human a useful picture of what happened?
  • Can a human correction become feedback the next run uses, or does it stay a one-off override?
  • Can we score agent workflows on outcomes instead of how good the trace looks?