Career.

I build and maintain independent projects during my sabbatical, spanning consumer software, AI agent infrastructure and scientific computing.

Local Pulse

I conceived and launched Local Pulse after noticing how much local culture remains visible on physical posters but difficult to find online. I own the product from discovery and scope through design, implementation, deployment and iteration.

The early ingestion pipeline used Python and FastAPI for image-and-text extraction, deduplication and enrichment. The current public application uses TypeScript, SolidJS, Hono/Bun, PostgreSQL and Cloudflare R2. Its MCP tools expose read-only event discovery and detail; publishing workflows use the CLI or web application.

• Built APIs, a publishing CLI and agent workflows for extracting and validating structured event listings.
• Developed automated checks and correction workflows to improve consistency and catch errors in AI-generated listings.
• Moved inference from an early hosted prototype to client-side CLI workflows. This reduced Local Pulse’s hosted agent inference cost from approximately €2 per poster to €0 per poster; client model usage and other hosting costs remain separate.
• Refined prompts and instructions, removed unnecessary model calls, and used failure traces to improve the workflow.

Live product

Azure AI agent runtime

I built a Python runtime and harness around Azure OpenAI through Microsoft Foundry. It supports streaming responses, durable sessions, memory tools and automatic context compaction so sessions can continue across interruptions.

PostgreSQL holds durable state; Redis supports sessions and coordination. API and worker services run in Azure Container Apps, with Terraform managing development and test infrastructure. The work includes recovery and concurrency exercises, telemetry and integration with managed cloud services.

This is an independent development and test platform. It has not been deployed as a commercial banking service.

Runtime source

Agent evaluation tooling

I built a custom TypeScript evaluation framework to compare AI coding assistants’ correctness and model usage with and without additional instructions. The work uses failure traces to test and improve agent guidance.

Evaluation framework

zdisamar

An independent Zig implementation of the oxygen A-band radiative-transfer and retrieval problem, with a Python interface and notebooks. The work explores reusing calculation state, reducing repeated computation and coarse-to-fine retrieval on synthetic spectra.

A paired 100-case synthetic retrieval benchmark on Apple M4 recorded median times of 1,228.826 seconds for the Fortran implementation and 3.624 seconds for Zig, with all 100 cases converging in each implementation. Each retrieved its own simulated spectrum; this measures that particular synthetic configuration and does not establish operational equivalence.

zdisamar source & benchmarks

MONKI GPU prototype

I supported KNMI scientist Victor Trees in exploring GPU acceleration of his Monte Carlo radiative-transfer model. I directed the research interface and optimisation choices, developed the prototype and compared it against a CPU reference.

The investigation covers divergent photon paths, memory access, backend comparison and code readability. Apple Metal is the local GPU target; broader CUDA and scientific validation require the relevant hardware and additional experiments.

MONKI prototype

Strategic Partnerships Lead · May–December 2025

Following the research team’s reassignment into strategy, I focused on lending and credit: product priorities, partner assessment, market-entry options and decision support for senior stakeholders.

• Co-developed lending-product strategy and priorities, contributing to Lido’s launch partnership on Aave’s new lending platform. The organisational launch followed in March 2026, after my contract ended.
• Researched private-credit market opportunities, commercial viability, strategic fit and the operational dependencies of potential partnerships.
• Spoke with customers, users and prospective partners; developed competitor and partner analysis and reports for C-level executives.
• Used AI-assisted, hypothesis-driven research and decision matrices to assess technical, financial and operational feasibility.
• Studied prospective partners’ products, teams, distribution and financial context to anticipate where their businesses were heading.

Aave V4 activation & Lido integration

Mechanism Designer, Research · March–May 2025

I researched DeFi applications, designed and proposed mechanisms, and assessed opportunities for integrations and new lending products. My work included memos and system designs for uncollateralised lending protocols.

I co-authored an industry-wide memo with executives and business-unit heads assessing five proposed Ethereum upgrades, translating security, performance and implementation trade-offs into recommendations. I also gave a recorded talk explaining Ethereum’s governance structure.

Ethereum upgrade recommendations

My work spanned core market-making contracts, performance engineering, deployment infrastructure, security, integrations, product development and business development.

Self-service market creation & deployment

I designed and built tooling that turned market launches into a self-service workflow. Previously, business leads coordinated developers, quantitative researchers and customers through coding, scheduling and review. The new tooling let customers launch markets with no handholding and let sales and support handle deployments independently.

Observed post-agreement rollouts fell from weeks or months of coordination to around 15–20 minutes, with an estimated 30 developer-hours saved per rollout. The tooling established an ongoing business line and packaged a standardised Curve deployment into a CLI workflow.

curve-core

Trading algorithms & performance engineering

I wrote smart contracts for Curve’s next-generation trading systems, implementing and refining mathematical models developed with quantitative researchers. Optimisation involved profiling, synthetic experiments, benchmarks, live test transactions and analysis of the financial behaviour of the algorithms.

The independent ChainSecurity audit documents a 75% reduction in gas consumption for the get_y trading calculation. This is a specific component result with shared mathematical and implementation contributions.

• Built line-by-line performance profiling adopted in the Vyper Titanoboa testing framework.
• Contributed integer square-root support to Vyper and cube-root functions to the Snekmate smart-contract library.
• Worked with compiler engineers on features required by the contracts and their performance constraints.
• Used property-based and stateful testing, differential tests against Python mathematics, unit tests and integration tests.

Independent audit

with boa.env.anchor():
    for d in self.depositors:
        prev_balances = [c.balanceOf(self.pool) for c in self.coins]
        tokens = self.pool.balanceOf(d)
        self.pool.remove_liquidity(tokens, [0] * 2, sender=d)

Incident response & contract hardening

During the July 2023 incident, I devised a recovery technique used in a team rescue of approximately $700,000. I participated in the response and subsequently led redesign and hardening work with contributors, business development and sales engineers.

That work helped restore confidence and bring deposits back to the next-generation contracts. By January 2025, the new stable pools held approximately $1.31 billion in deposits. The recovery and returning liquidity were shared outcomes.

What failed, and how we recovered funds

The root cause was in compiled code. Affected Vyper versions assigned separate storage locations to functions that were meant to share a named reentrancy lock. An external call could therefore re-enter another function while the pool’s accounting still reflected an earlier state. The compiler team’s advisory documents the affected versions and the combination of conditions required.

After the initial attacks, the remaining CRV/ETH pool was difficult to operate because its recorded balances and pricing checks no longer matched a normal market state. I proposed using another donation and fee-claim operation to raise the virtual price enough for the recovery sequence to proceed. The team then worked through the numerical parameters, rescue implementation, gas costs and private transaction submission.

Addison Spiegel’s first-hand account credits this proposal to my handle, Bout3Fiddy. It also records the separate work of Addison, Robert Chen, Chainlight and Flashbots across the rescues. The later team operation recovered approximately $700,000. Its success depended on the combined analysis, implementation and transaction delivery.

Contemporary reporting: Fortune’s July 31 report on the earlier $5.4 million recovery.

Rebuilding the contracts

The response continued beyond the rescue. I worked on reducing the situations in which a single guard failure could become a loss of funds, simplifying sensitive interfaces and making reserve accounting easier to inspect. These changes involved trade-offs: removing a convenient transfer path, preserving compatibility where it was useful, and helping integrators adopt the new transaction flows.

Three concrete design changes illustrate this work:

1. Approval-free swaps. Added an entry point for assets transferred to the pool earlier in the same transaction, reducing dependence on standing token approvals and avoiding redundant transfers in multi-pool routes.
2. Fewer execution handoffs. Reduced opportunities to pass control to external contracts during an operation, alongside state-bookkeeping changes.
3. Smaller, explicit interfaces. Removed unintended side effects from fee-claiming functions, making behaviour easier to reason about and review.

_dx: uint256 = ERC20(coins[coin_idx]).balanceOf(self)

if expect_optimistic_transfer:
    _dx = _dx - self.stored_balances[coin_idx]
    assert _dx >= dx

@internal
def _transfer_out(_coin_idx: uint256, _amount: uint256, receiver: address):
    self.balances[_coin_idx] -= _amount
    assert ERC20(coins[_coin_idx]).transfer(
        receiver,
        _amount,
        default_return_value=True
    )

xcp_profit: uint256 = self.xcp_profit
xcp_profit_a: uint256 = self.xcp_profit_a
current_lp_token_supply: uint256 = self.totalSupply

if xcp_profit <= xcp_profit_a or current_lp_token_supply < 10**18:
    return

balances: uint256[N_COINS] = self.balances

Delivery included external security review, documentation, notebooks and direct work with integrators and arbitrageurs so they could use the interfaces correctly.

Contract-hardening pull request

Fee conversion & cross-chain system design

I designed the fee-conversion interface around user and business needs, replacing a slow, costly process requiring manual coding intervention with more reliable automation. Colleagues implemented the burner. Recorded Ethereum conversions through the system totalled approximately $19 million from July 2024 through October 2026; this is system throughput across that period.

I also designed FastBridge: a lending-based mechanism to give users access to funds ahead of the usual seven-day settlement delay while coordinating state across independent systems. Others implemented the design.

Fee-conversion architecture

Beyond implementation

I contributed to hiring, assessed partners and strategic opportunities, sourced leads, and represented Curve in discussions where product, security and commercial considerations met. I advised engineers on architectural choices and worked with users to understand what would make the system useful.

I also designed a fundraising-gauge mechanism in Vyper and worked through DAO governance to fund compiler infrastructure.

Vyper fundraising proposal

I was hired as the first analyst at LlamaRisk, then called Cryptorisks. The work grew out of close protocol research and publicly shared on-chain analysis.

I helped establish qualitative risk assessment for digital-asset protocols: examining mechanisms, governance, custody, price oracles, incentives and failure scenarios alongside quantitative evidence.

• Published protocol and stablecoin risk assessments for Curve liquidity providers and governance participants.
• Analysed Terra/UST before its collapse, including falling Anchor yields, liquidity withdrawal, de-pegging and liquidation-cascade scenarios.
• Traced the interaction between Abracadabra’s leveraged Degenbox strategy and Anchor’s yield reserves.
• Published research on RAI and Angle’s agEUR, and an introductory explanation of custody risk.
• Built and shared on-chain analytics to support the research.

Collected LlamaRisk writing

I developed forecasting models and the software around them for live electricity trading and physical asset management, working with ML engineers, quantitative researchers and product stakeholders.

Forecasting & live trading

• Built a short-term electricity-price forecasting model for Great Britain from scratch, including feature engineering and supporting trading software.
• Developed models for Dutch imbalance markets and GB intraday markets.
• Backtested and validated models, then connected predictions to day-to-day trading decisions.
• Built the prototype and scaffolding for a containerised ML service delivering predictions through Kafka.
• Implemented watchdogs and code-level checks that validated predictions against trading risk limits.
• Worked with colleagues to develop machine-learning strategies for proprietary trading and a pilot in new markets.

Physical assets

My forecasting model supported management of the IJmond plant at Tata Steel’s IJmuiden site, which has 144 MW of electrical capacity. I also integrated ML models into renewable-asset management systems, including the 122 MW Princess Alexia Wind Farm.

I estimate that the IJmond forecasting work generated around €60,000 in additional weekly net revenue during its use. This is a recalled estimate.

Tools for the people making decisions

I built real-time indicators and dashboards for traders and stakeholders, including work outside planned sprints when I saw a need. I developed the software scaffolding around the models, operationalised them and worked with stakeholders to secure adoption.

Princess Alexia Wind Farm

At the Royal Netherlands Meteorological Institute, I developed methods for retrieving aerosol-layer height from satellite observations. The work combined atmospheric physics, numerical methods, neural networks and operational algorithm development for European satellite missions.

Making aerosol-height retrieval operationally feasible

I developed neural-network radiative-transfer methods to replace expensive calculations in a legacy Fortran95 workflow. The published TROPOMI study trained three neural networks on 500,000 simulated spectra, covering radiance and derivatives with respect to aerosol height and optical thickness.

The study reported retrieval-processing times of 184.01 seconds per pixel for the line-by-line approach and 0.167 seconds with the neural-network processor—approximately 1,100× faster. This brought the aerosol-height retrieval within operational processing capacity.

Retrieval methods & validation

• Developed weighted-least-squares dynamic scaling to reduce retrieval bias over bright surfaces, evaluated using synthetic spectra and GOME-2 observations of wildfire plumes.
• Compared TROPOMI aerosol heights with CALIOP profiles in four selected cases involving around 800 co-located pixels, investigating surface and cloud effects.
• Co-authored a study of aerosol heights during the 2018 North American fire season, comparing TROPOMI with MISR and CALIOP.
• Developed and implemented the aerosol layer-height retrieval algorithm as part of the Sentinel-4 Level-2 team.
• Supported operational adoption through scientific papers, algorithm documentation and user manuals.

The research continued to inform satellite products and model development after my employment at KNMI ended. I completed and received my TU Delft PhD in 2022.

Neural-network paper · 2019

I contribute to the open-source tools and numerical primitives that my applications depend on. This work reaches into Vyper’s compiler, Titanoboa’s interpreter and testing environment, and Snekmate’s mathematical library.

Vyper: bringing integer square root into the compiler

I added the isqrt built-in to Vyper, merged in August 2022. It returns the integer square root rounded down, so isqrt(101) returns 10. The contribution integrated the routine into compiler IR generation, registered its argument and return types, and added documentation and tests.

The implementation built on Michael Egorov’s Vyper adaptation of the Solmate algorithm. My work brought that implementation into the language itself and tested it across literal values, variables, storage, memory interactions and the uint256 range. The tests compare results with Python’s math.isqrt and check the defining bounds: r² ≤ x < (r + 1)².

z = unsafe_div(unsafe_add(unsafe_div(x, z), z), 2)
# Six further refinements in the implementation.
z = min(z, unsafe_div(x, z))

Vyper integer-square-root contribution

Snekmate: cube-root routines

I contributed the original cube-root implementation to Snekmate in March 2023, adapting the numerical work used in Curve’s trading mathematics into reusable library functions. On the EVM, numerical methods have to account for integer rounding, overflow, bytecode size and the execution cost of every refinement.

The early implementation used magnitude-dependent scaling to support large inputs. That introduced precision trade-offs in the fixed-point path. Later investigation showed why those trade-offs needed to be treated separately from the integer cube root’s promise to return an exact floor.

Original cube-root contribution

2026 follow-up: tighter guesses and earlier convergence

I revisited the cube-root implementation and reported a large-input rounding bug: the integer routine could return one above the true floor because it reused the scaled fixed-point calculation. My investigation also examined a newer initial-guess construction from the Solady and 0x implementation lineage, which starts closer to the answer and requires fewer Newton refinements.

Snekmate’s maintainer integrated the fix in October 2026. The replacement calculates the integer root directly, selects one of three seed multipliers from the input’s binary magnitude, and uses five unrolled iterations instead of seven. A final correction enforces downward rounding. The merged change reports approximately 400 gas saved on average, with a documented range of roughly 1,100–1,400 gas depending on the input and rounding mode.

The verification also targets values immediately around perfect cubes: n³ − 1, n³ and n³ + 1. Those transitions are particularly important for rounding correctness and are unlikely to appear in uniform random sampling over a 256-bit input range. The fixed-point routine retains its separate, documented approximation behaviour.

log2x: uint256 = self._log2(x, False)
y: uint256 = (
    (
        ((9_483_749 >> unsafe_mul(8, unsafe_sub(2, log2x % 3))) & convert(max_value(uint8), uint256))
        << unsafe_div(log2x, 3)
    )
    >> 7
) | 1

y = unsafe_div(unsafe_add(unsafe_mul(2, y), unsafe_div(x, unsafe_mul(y, y))), 3)
# Four further Newton steps in the implementation.
if unsafe_div(x, unsafe_mul(y, y)) < y:
    y = unsafe_sub(y, 1)

Merged precision fix and cube-root optimisation

Titanoboa: interpreter tooling, testing and profiling

My contributions to Titanoboa made it easier to investigate Vyper contracts from Python. I added call-level and source-line gas profiling, connecting execution results to the functions and lines responsible for the cost. The output records statistics across calls and follows child computations, helping developers identify expensive calculations inside multi-contract execution.

I subsequently improved the profiling reports, including sorting by median gas cost to make computational hotspots easier to find when storage operations distort averages. I also contributed Brownie-derived testing utilities for strategies, stateful tests and test isolation, alongside fixes to decoding and debugging paths and helpers such as time travel.

These tools supported the same workflow I used on the numerical routines: form a hypothesis, run it against real compiled execution, inspect the costs and edge cases, and turn the result into a repeatable test.

@pytest.mark.profile
def test_external_call(source_contract):
    source_contract.bar(10)

Titanoboa profiling implementation and tests

PhD · Atmospheric Remote Sensing · 2022

Developing an aerosol layer-height retrieval algorithm for passive satellite measurements. Research undertaken with TU Delft and KNMI, supervised by Pieternel Levelt, Pepijn Veefkind and Martin de Graaf.

Doctoral studies: November 2015–September 2022. KNMI employment ran from October 2015 to September 2019.

Doctoral thesis

MSc · Applied Earth Sciences · 2013–2015

TU Delft. Focus on satellite remote sensing and algorithm development for measuring ice sheets.

Earlier studies

My background in civil engineering led to a remote-sensing topic for my final paper in 2012.

Certification

HashiCorp Certified: Terraform Associate (004).

Credential

Languages & data

Python, TypeScript, SQL, Vyper; PostgreSQL and Redis.

AI & scientific work

Neural networks, machine learning, Azure OpenAI, Microsoft Foundry, agent runtimes, context engineering, evaluation workflows and MCP. NumPy, pandas, scikit-learn, matplotlib, seaborn, PySpark and Databricks.

Services & delivery

FastAPI, Hono/Bun, SolidJS, REST APIs, Kafka, Docker, Terraform, Git and CI/CD. Azure, GCP and Cloudflare.

Engineering methods

Profiling, numerical optimisation, stateful and property-based testing, differential testing, incident response, integration support and documentation.

Spoken languages

English, Hindi and Oriya; conversational Dutch.