Econstellar: An Open-Source AI-Augmented Research Engine for Computational Financial Econometrics
arXiv:2606.05705v1 [econ.EM] 4 Jun 2026
Avishek Bhandari∗ June 5, 2026
Abstract Turning a promising economic idea into a credible empirical finding is, in practice, an expensive undertaking: it demands a great deal of specialised computation, and the results are seldom released in a form that others can check or build upon. Econstellar is our response. It is an open, publicly served research engine that runs publication-grade financial econometrics from an ordinary web browser and explains what the results mean, so that a reader does not merely read a finding but can re-run it, vary its inputs, and trace exactly how it was produced. Three choices give the system its character. The heavy computation is placed on the processor that suits it, rather than forced onto hardware ill-matched to the task, which is much of the reason analysis of this kind is so rarely served to the public. An artificial-intelligence assistant selects and interprets the analyses but never originates a number, so every quantity it reports is a real computation the reader can reproduce. And the engine a visitor exercises is the same code that produced the figures in our published research. We expose seventeen econometric methods, each reported with a verified live value and reproducible at the public endpoint, computed under a single discipline: prices are treated as non-stationary and all methods are applied to returns. The system also regenerates, on demand, the headline result of an accompanying study of financial contagion, from the package that generated it. The platform is the working core of an active research programme spanning three software releases and three preprints, and it is available now, free and open-source, at a live public address. Our aim is a simple one: to shorten the distance between a research claim and the moment another person can independently verify it.
Keywords: open-source econometrics; transfer entropy; financial contagion; reproducible research; sandboxed computation; AI-augmented analysis; wavelet methods; systemic risk. JEL classification: C58, C63, C88, G15. ACM CCS: Software and its engineering → Software architectures; Applied computing → Economics; Information systems → Web applications.
1
Introduction
The distance between a suggestive working paper and a defensible empirical submission in computational economics is, more often than not, one to two orders of magnitude of floating-point work, ∗
School of Humanities, Social Sciences and Management, Indian Institute of Technology Bhubaneswar. Email: [email protected]. Code and live demonstration: https://avishekb9.github.io/econstellar/.
1
paid almost entirely in compute. A network-econometric result that is gestured at in a seminar, an estimated spillover or a directed information-flow graph, becomes a publishable object only after surrogate nulls, bootstrap intervals, rolling re-estimation, and robustness across specifications have been computed, and that arithmetic is rarely exposed in a form a reader can re-execute. It may be noted that the replication literature has documented the consequence directly: a substantial fraction of published empirical economics cannot be reproduced from the materials provided [Chang and Li, 2022], and a parallel literature in the computational sciences has codified the practices that would prevent it [Sandve et al., 2013]. The gap is not principally one of intent; it is that the computation itself is heavy, irregular, and seldom served. A natural response would be to accelerate the heavy step on graphics processors, as has been done with conspicuous success for dynamic-equilibrium models whose inner loops are dense and regular [Aldrich et al., 2011]. The central information-theoretic primitive of network contagion analysis, however, resists that route. Directed information flow between return series is measured by transfer entropy [Schreiber, 2000], and its exact estimator in continuous state spaces is the nearest-neighbour construction of Kraskov et al. [2004], which rests on k-d-tree range searches. The control flow of a k-d-tree traversal is data-dependent and branch-divergent: queries issued together descend different subtrees, prune at different nodes, and terminate at different depths. On single-instruction-multiple-thread accelerators such divergence serialises the threads of a warp, because the hardware must execute the taken and untaken sides of each branch in turn [Fung et al., 2007]. The computation is, in consequence, pointer-chasing and memory-latency-bound rather than arithmetic-bound, which is precisely the profile for which graphics processors are ill-suited. Exact information-theoretic contagion estimation is, in short, a central-processing-unit workload, and the architectural premise of the system described here follows from that fact: the heavy econometrics is sited on the processor that suits it, and only the interpretive and data-gathering layers are delegated to managed services. What does not exist, to our knowledge, is an open, sandboxed, publicly served econometrics engine that combines information-theoretic contagion estimation of this kind with artificialintelligence-augmented interpretation and live reproducibility, so that a reader may not only read a result but re-run it, vary its parameters, and obtain a grounded explanation, all from a browser and without installing anything. Econstellar is built to close that gap. It is a research engine, in the literal sense that the same deployed code that produces the figures of the group’s substantive papers is the code a visitor exercises at the public endpoint. The present paper documents the system: its architecture and the security model that a public computation endpoint requires (Section 2); the methodological substrate of eight primitives that the seventeen served methods instantiate (Section 3); the seventeen methods with their verified live values and the stationarity discipline under which they are computed (Section 4); and the published software and preprints that the engine supports, together with the reproduce-the-paper facility that ties them to live computation (Section 5); and its live surfaces and how to navigate them (Section 6). Section 7 concludes.
2
Browser client
GitHub Pages portal (static SPA, zero dependencies) landing · catalog-driven workbench · reproduce-the-paper · NEURICX strip
NEURICX (Cloud Run) GDELT → classify → geocoded feed
Compute engine (Cloud Run) parameterised-only registry → 17 R methods, network-isolated
Vertex AI agent Dialogflow CX NL → tool → R
Stored G20 panel Yahoo / FRED (live prices)
GCS artifacts
Gemini 2.5 Flash (chat) Pro + search (research)
BigQuery warehouse dataset neuricx
Dedicated CPU-HPC node (planned): full 18market panel, exact KSG k-NN transfer entropy
Figure 1: The Econstellar system. A static single-page application on GitHub Pages is the only public surface a reader touches; it reads the engine’s method catalogue at runtime and renders results client-side. Three Cloud Run services sit behind it: the sandboxed compute engine, which exposes seventeen registered econometric methods over a parameterised-only registry and executes each in a network-isolated R subprocess; the NEURICX news-intelligence service; and a Vertex AI conversational agent. The language model (Gemini 2.5) is called only to interpret results and classify news, never to originate quantities. Persistent state lives in Google Cloud Storage and a BigQuery longitudinal warehouse. A dedicated CPU-HPC node (dashed) is the planned route to the full eighteen-market panel and an exact nearest-neighbour transfer-entropy implementation.
2
Architecture
The system has four parts: a sandboxed compute engine, a two-tier analyst built on a language model, a live news-intelligence service with a longitudinal warehouse, and a public workbench. The reader touches only the last of these. Figure 1 gives the overall arrangement: a static single-page application on GitHub Pages is the sole public surface, and it reads the engine’s method catalogue at runtime and renders results client-side, while three Cloud Run services and two storage back-ends sit behind it. We take the four parts in turn.
2.1
The sandboxed compute engine
The compute engine is a zero-dependency Node.js orchestrator that exposes a single registered analysis as an HTTP endpoint. The public surface accepts a method name and a set of typed parameters, validates them against a fixed registry schema, and never accepts executable code. An accepted call spawns one R runner script in a disposable subprocess with no network egress, a 3
read-only root, an ephemeral scratch directory, and a wall-clock timeout; an unrecognised method name or a malformed parameter is rejected before any process is spawned. The primary security guarantee is therefore the registry itself: the endpoint can perform exactly the finite, reviewed list of registered analyses and nothing besides. On the local development host the subprocess is additionally confined by a user namespace with the network unshared (bwrap –unshare-net); on Cloud Run the same network isolation and wall-clock timeout are enforced within the platform’s managed container sandbox, and a live run reports its sandbox state as network-isolated with a timeout rather than as a privileged in-process jail, which is the honest description of what the managed environment grants. It is pertinent to describe the threat model explicitly, because the endpoint is public by design and the design is intentional. The adversary is any anonymous caller; the asset to be protected is the underlying compute account and its credentials; and the attack surface is the request body. Because the registry admits only a method name and typed parameters, there is no path by which a caller can cause arbitrary code to execute, exfiltrate data over the network from inside a runner, or escalate beyond the finite menu of analyses. The remaining risk is resource exhaustion, which is bounded by layered limits: per-address rate limits of twenty, ten, and five requests per minute for the compute, fast-analyst, and deep-research endpoints respectively; per-address daily ceilings on the two paid analyst endpoints; a global concurrency ceiling that sheds load rather than queueing it unboundedly; and a global daily ceiling on calls to the language model, so that the monetary exposure of the public endpoint is capped irrespective of the number of callers. We notice that these limits are a property of the orchestrator, not of the network perimeter, and so they hold uniformly across the local and deployed configurations.
2.2
The artificial-intelligence analyst layer
Interpretation is provided in two tiers, and both are constructed so that the language model chooses and explains analyses without ever producing their numbers. The fast analyst answers a naturallanguage question by function calling: the model is given a single tool, run_analysis(method, params), whose schema is generated from the same method registry that governs the compute endpoint, so the model can request only registered analyses with validated arguments, and it sees the engine’s actual JSON output before it composes a reply. The deep-research assistant runs in two phases. In the first, an agentic loop executes live econometrics through the same tool, accumulating results; in the second, those results are summarised into context and a grounded synthesis is produced with real citations retrieved by web search. The two phases are deliberately not combined into a single model request, because pairing search grounding with function calling in one call is fragile; separating them keeps each phase simple and auditable. The key property of this layer is that the language model does not originate numbers. Every quantitative claim in a generated answer is the output of a sandboxed computation that the reader can reproduce through the same public endpoint; the model’s role is confined to selecting which registered analysis to run, reading its structured result, and composing an interpretation in prose. 4
This is the central architectural decision of the analyst layer, and it is what distinguishes a grounded research assistant from a fluent but unverifiable one: the engine is the source of every figure, and the model is the source only of the words around it. A third interface, a Vertex AI conversational agent, exposes the same tool through a managed dialogue runtime, and has been confirmed end-toend from a natural-language request to an R computation, returning, for example, an augmented Dickey-Fuller statistic of −52.64 for United Kingdom equity returns, which is the value the compute endpoint returns for that series.
2.3
NEURICX: live financial intelligence
The third service, NEURICX, supplies live financial-news intelligence. It draws articles from the GDELT global news index, classifies each by transmission channel with a language model, geocodes the result, and renders it as a map feed; when the upstream index rate-limits the service, a disk cache supplies a stale fallback so that the feed degrades rather than fails. Each classified pull is persisted to a BigQuery warehouse, so that channel intensity, sentiment, and a systemic-stress index accumulate as a queryable longitudinal record rather than a transient view. The warehouse is what turns a live feed into a research input: a question about how a given channel’s intensity evolved across an episode is answered from stored history rather than re-scraped on demand.
2.4
The public research workbench
The workbench is a single-page application written in dependency-free JavaScript and served as static files from GitHub Pages. It reads the engine’s catalogue at runtime and never hardcodes a method name, so the interface for a method appears as soon as the method is registered: enumerated parameters render as menus, numeric parameters as typed inputs, and each of the seventeen methods has a dedicated result renderer, including a force-directed drawing of the estimated network from layout coordinates returned by the engine. A deep-research pane and a news strip surface the other two services in the same page. Two properties make the workbench a reproducibility instrument and not merely a console. First, every result is stamped with its provenance: the method, its version, the engine revision that produced it, the parameters, the data vintage, a timestamp, and a permalink that re-runs the identical analysis. Second, results export as CSV or JSON and carry a generated BibTeX entry, and a dedicated page regenerates the headline results of the group’s published work live, through the same engine that produced them, so that a reader can move from a claim in a paper to its recomputation in a single step.
3
The Methodological Substrate
The seventeen served methods are not a miscellany; they instantiate a small substrate of eight estimation primitives that recur across the group’s substantive work on contagion, long memory, and network formation. We state each primitive with its defining equation, in the form used in the group’s methodological work, and then map the served methods onto them in Table 1. The 5
equations are reproduced for reference and completeness; the contribution of this section is the observation that a compact and reusable substrate underlies an apparently diverse method menu. P1: long memory. Detrended fluctuation analysis measures the scaling of the integrated, locally detrended return profile and returns the Hurst exponent H [Peng et al., 1994]: v u N u1 X 2 t F (s) = Y (i) − Yfit (i) ∝ sH , N
(1)
i=1
where Y (i) =
Pi
t=1 (xt − x̄) is the integrated return profile, N
the series length, Yfit the local
least-squares polynomial trend within each window of length s, and H > 12 signals persistent long memory. P2: multi-scale variance. The maximal-overlap discrete wavelet transform decomposes return variance scale by scale [Percival and Walden, 2000, Gençay et al., 2005]: σx2 =
X
νx2 (τj ),
νx2 (τj ) =
j≥1
1 X 2 Wj,t , N t
(2)
where νx2 (τj ) is the wavelet variance at scale τj = 2 j−1 and Wj,t are the level-j wavelet coefficients. P3: directed information flow. Transfer entropy measures directed dependence [Schreiber, 2000], TEY →X = (d)
(d)
with xt , yt
X
(d) (d) p xt+1 | xt , yt (d) (d) p xt+1 , xt , yt log , (d) p xt+1 | xt
(3)
the delay embeddings. Its exact estimation in continuous spaces uses the Kozachenko-
Leonenko differential-entropy estimator, m b H(Z) = −ψ(k) + ψ(N ) + log cm + N
N X
log εi ,
(4)
i=1
and the nearest-neighbour mutual-information correction of Kraskov et al. [2004], 1 b I(X; Y ) = ψ(k) + ψ(N ) − N
N X
ψ(nx,i + 1) + ψ(ny,i + 1) ,
(5)
i=1
where ψ is the digamma function, εi twice the distance to the kth neighbour, cm the volume of the unit m-ball with m the embedding dimension, and nx,i , ny,i the marginal neighbour counts; in the Gaussian case the measure coincides with Granger causality [Barnett et al., 2009]. It is the k-d-tree search underlying (5) whose irregular control flow motivates the processor choice of Section 1.
6
P4: surrogate significance. Directional significance is assessed against an ensemble of phasepreserving surrogates [Theiler et al., 1992]: p̂Y →X =
(b) c Y →X } 1 + #{ b : TEsurr ≥ TE , B+1
(6)
the one-sided empirical p-value of the observed flow against B surrogate replicates. P5: community structure. Community structure is summarised by modularity [Newman, 2006]: Q=
ki kj 1 X Aij − δ(ci , cj ), 2m 2m
(7)
i,j
with A the weighted adjacency, ki node strength, m = 12
P
i ki , and δ(ci , cj ) = 1 when nodes share
a community. P6: network formation. The directed dependency graph retains only edges that survive the surrogate test [Diebold and Yilmaz, 2012]: E = {(i → j) : p̂i→j < α}.
(8)
P7: channel attribution. Measured contagion is attributed to economic channels by an instrumented regression [Bhandari et al., 2026a]: Cij =
X
(c)
βc Zij + uij ,
(9)
c (c)
where Zij are channel proxies (trade, financial, and related) and βc , estimated by two-stage least squares with external instruments, is each channel’s transmission share. P8: discriminatory validation. Crisis-classification performance is measured by the area under the receiver-operating-characteristic curve, with competing indices compared by the correlated-AUC test of DeLong et al. [1988]: AUC = P scrisis > scalm ,
(10)
the probability that the index scores a randomly chosen crisis period above a randomly chosen calm period.
4
Verified Results
The seventeen methods are listed in Table 2, each with a value produced by the deployed engine. We wish to be explicit about the status of these numbers: every value in the table was produced by the live sandboxed engine on the stored G20 equity panel and is reproducible at the public endpoint 7
Table 1: The eight substrate primitives and the served methods that instantiate them. A method may draw on more than one primitive; the dominant primitives are listed. Primitive
Equation
Served methods (Section 4)
P1 long memory P2 multi-scale variance P3 directed information P4 surrogate significance P5 community structure P6 network formation P7 channel attribution P8 discriminatory validation
(1) (2) (3)–(5) (6) (7) (8) (9) (10)
dfa_hurst wavelet, wavelet_coherence, soch_profile wqte, granger, soch_profile, quantile_var wqte, soch_profile network granger, network, connectedness connectedness, spillover_rolling systemic-risk validation (Section 4)
Standard time-series machinery: unit_root, live_unit_root, panel_unit_root, var_irf, vecm, garch, rolling_dcc provide the stationarity gate, dynamics, and volatility on which the primitives rest.
by issuing the corresponding registered call. The four most recently added methods were re-run, uncached, at the time of writing, and the remainder were verified live against the deployed revision. The values are reported as the engine returns them and are not rounded differently for presentation. It is pertinent to state the stationarity discipline that governs the entire menu, since it is the single methodological rule on which the validity of the others depends. Price levels are integrated of order one, and returns are stationary; transfer entropy and every other method in the table are therefore applied to log-returns throughout, and the engine never reports a price level as stationary. The live_unit_root method makes the rule operational on live data, testing levels and returns separately and reporting, for the S&P 500, a level series integrated of order one and a return series of order zero. It may be noted that a single result deserves emphasis, because it is the clearest demonstration that the engine serves the same computation that the group’s papers report rather than a separate re-implementation. The soch_profile method calls the published sochcontagion package directly, and on the United-States-to-India pair at the five-percent tail it returns a directed wavelet-quantile profile that rises monotonically across the four resolved scales, (0.0155, 0.0425, 0.0491, 0.0494) from the two-to-four-day band to a peak at the sixteen-to-thirty-two-day band, with a four-scale aggregate of 0.039. These per-scale gains are, to the precision displayed, the first four of the five reported for the same pair in the accompanying study [Bhandari and Parida, 2026a]; that study carries the decomposition one band further, so its five-scale aggregate is the slightly larger 0.0426, the difference being the additional thirty-two-to-sixty-four-day scale and not any difference in computation. We observe that wqte, a transparent quantile-regression realisation of the same measure family, returns the same four-scale aggregate, 0.039, the internal agreement one would expect between an independent realisation and the published estimator. The substrate also supports validated systemic-risk measurement in the wider research programme, and it is appropriate to report its performance honestly rather than selectively.
A
systemic-risk index built on the directed-flow primitives attains an area under the receiver-operatingcharacteristic curve of 0.915 in classifying the COVID-19 crisis on a United States equity sample, 8
Table 2: The seventeen served methods with verified live values on the stored G20 equity panel (eighteen markets, daily log-returns, 2006–2026). Each value is produced by the deployed engine and is reproducible at the public endpoint. India, USA, and UK denote the equity indices of those economies. Method
Class
Verified live value
unit_root live_unit_root panel_unit_root var_irf vecm garch rolling_dcc dfa_hurst wavelet wavelet_coherence wqte soch_profile quantile_var granger connectedness spillover_rolling network
stationarity stationarity (live) stationarity (panel) dynamics cointegration volatility time-varying corr. long memory (P1) multi-scale (P2) multi-scale (P2) contagion (P3,P4) contagion (P2,P3) tail dynamics (P3) causality (P3,P6) spillover (P6,P7) spillover (P7) topology (P5,P6)
India ADF −49.18; UK −52.64 S&P levels I(1) / returns I(0) 5-market: IPS −77.26, LLC −51.79 lag 7, maximal root 0.705 (stable) India/USA/UK rank 3 (trace 7265.97 → 1851.19) India α + β = 0.991 India–USA mean ρ = 0.23 (0.15–0.31) India H = 0.542 India d1 = 47.07% of variance USA/India mean 0.249, peak d6 USA→India τ.05 agg. 0.039, rising d1–d4 USA→India agg. 0.039, peak d4 (published package) India/USA/UK τ.05 : USA top driver (net +0.70) 6-market: 6 edges, USA out-degree 3 India/USA/UK TCI 30.25% (S 15.05/M 11.56/L 3.64) India/USA/UK TCI 10.5–46.3% (mean 28.4) 6-market: 18 edges, directed density 0.60, 6 communities
with a one-day early-warning lead; this is informative discrimination, though it sits modestly below the contemporaneous VIX benchmark (0.947), the lead time being the index’s advantage rather than the level [Bhandari, 2025a]. On the harder problem of trade-policy-induced stress in the Indian market the same index, augmented with a trade-policy-uncertainty signal, attains an AUC of 0.581 against 0.531 for the India VIX, a modest but statistically discernible improvement (p = 0.030 by the test of DeLong et al. [1988]). The contrast between the two episodes is itself the substantive point: the architecture serves the favourable and the unfavourable result on the same footing, and reports each with its benchmark.
5
Research Outputs and Reproducibility
The engine is not a demonstration built apart from the group’s research; it is the deployment of that research. Three software releases underlie it. The contagionchannels package, which implements the channel-attribution primitive of (9), and the ManyIVsNets package, which supplies the many-instrument network estimation it draws on, are both released on the Comprehensive R Archive Network [Bhandari et al., 2026b, Bhandari, 2025b]. The sochcontagion package, which the soch_profile method calls, is released publicly under the GNU General Public Licence and passes a clean package check (zero errors, zero warnings, two expected notes, and forty-four of forty-four unit tests), and is prepared for archive submission [Bhandari and Parida, 2026b]. The compute engine and the workbench are released under permissive licences [Bhandari, 2026a,b], and the news-intelligence service likewise [Bhandari, 2026c].
9
Three preprints document the substantive results that the substrate produces: the multi-scale network analysis of systemic risk and its early-warning validation [Bhandari, 2025a], the channelidentification and attribution study [Bhandari et al., 2026a], and the scale-ordered contagion theory whose directed profile the engine reproduces [Bhandari and Parida, 2026a]. The connection between the preprints and the engine is not nominal. The reproduce-the-paper facility of the workbench regenerates the headline directed-contagion profile of the scale-ordered study live, at the public endpoint, through the same sochcontagion code that generated the figure in the manuscript, and the regenerated profile reproduces the published one’s rising shape and its per-scale gains. Each served result, moreover, carries the provenance stamp described in Section 2.4, so that the path from a number on the screen to the registered call, engine revision, and data vintage that produced it is explicit. In this sense the system is an attempt to make the reproducibility practices that the computational-science literature recommends [Sandve et al., 2013] the default behaviour of a served research instrument rather than an after-the-fact appendix, in a subfield where reproduction has been the exception [Chang and Li, 2022].
6
Availability and Navigation
The system is open and live, and a reader is encouraged to exercise it directly rather than take the values of Section 4 on trust. Table 3 collects the public addresses. The portal is the place to begin: from it the workbench runs any of the seventeen methods, the reproduce page regenerates the directed-contagion profile discussed above, and a short changelog records what has been added. The compute engine is itself a small and self-describing interface. A reader, or a script, first retrieves the live method catalogue from /api/compute/catalog, which lists every method with its typed parameters and is the same catalogue the workbench reads to build itself, and then issues a single registered call to /api/compute/run with a method name and parameters. To reproduce the first row of Table 2, for instance, one requests the method unit_root with parameter series set to India and receives the augmented Dickey-Fuller and KPSS statistics together with the provenance stamp of Section 2.4; the identical computation is a single selection in the workbench, and the permalink it returns reproduces it exactly. The source for the engine, the workbench, and the news service, together with the three R packages, is public under permissive licences [Bhandari, 2026a,b,c].
7
Conclusion
Econstellar is a sandboxed, publicly served econometrics engine with an artificial-intelligence interpretation layer, a live news warehouse, and a reproducibility workbench. Three design decisions give it whatever value it has. The computation is parameterised-only, so that a public endpoint can be exposed without exposing a path to arbitrary execution. The language model interprets but does not originate numbers, so that every quantitative claim it makes is the output of a reproducible computation rather than a generated assertion. And the heavy estimation is sited on the central
10
Table 3: Live surfaces and the principal compute-engine endpoints. The portal is the entry point; every served result is reproducible through the run endpoint and carries a permalink. What
Address
Portal (start here) Workbench (run any method) Reproduce the paper Changelog (what is new) Compute API (base) liveness + method count method catalogue run one method Source code R packages
https://avishekb9.github.io/econstellar/ https://avishekb9.github.io/econstellar/research-engine.html https://avishekb9.github.io/econstellar/reproduce.html https://avishekb9.github.io/econstellar/changelog.html https://shssm-compute-b7ui3oxaqq-el.a.run.app GET /health GET /api/compute/catalog POST /api/compute/run {method, params} github.com/avishekb9/{compute-engine, econstellar, NEURICX} sochcontagion · contagionchannels · ManyIVsNets
processing unit, because the irregular, memory-latency-bound nearest-neighbour search at the core of exact transfer entropy is not an accelerator workload. Together these choices make it possible to move from a claim in a paper to its live recomputation in a browser, which is the property the system was built to provide. In view of the above, the natural next steps are of three kinds. The published package that the engine serves is prepared for archive submission, and a software-paper submission to an opensource journal would document the engine itself in citable form. The empirical menu would be sharpened by a nearest-neighbour transfer-entropy implementation of the wavelet-quantile measure and by extension to the full eighteen-market panel, both of which are the workloads for which the planned dedicated central-processing-unit node of Figure 1 is intended. We observe, finally, that the substrate is small and the method menu grows by registering new runners against it; the architecture is therefore one in which the distance between a new method in a working paper and a served, reproducible analysis is, by construction, short.
Acknowledgements The author thanks the Google Cloud Education Programs for a research credits award under the Google Cloud Research Credits Programme (credit reference wilsonjessica-485604931), which funds the cloud infrastructure, AI services, and data-warehouse layer of the deployed platform. The laboratory workstation and mobile workstation on which the engine’s R methods run and are developed were procured under Institute Seed Grant SP128 (Innovative Approaches for Analyzing Financial Market Dynamics: Computational Financial Analysis with Wavelets, Networks, and Statistical Learning Powered by High-Performance Computing), funded by the Indian Institute of Technology Bhubaneswar (Sponsored Research and Industrial Consultancy, sanction dated 18 November 2023).
11
References Eric M. Aldrich, Jesús Fernández-Villaverde, A. Ronald Gallant, and Juan F. Rubio-Ramírez. Tapping the supercomputer under your desk: Solving dynamic equilibrium models with graphics processors. Journal of Economic Dynamics and Control, 35(3):386–393, 2011. doi: 10.1016/j. jedc.2010.10.001. Lionel Barnett, Adam B. Barrett, and Anil K. Seth. Granger causality and transfer entropy are equivalent for Gaussian variables. Physical Review Letters, 103(23):238701, 2009. doi: 10.1103/ PhysRevLett.103.238701. Avishek Bhandari. Multi-scale network dynamics and systemic risk: A Model Context Protocol approach to financial markets. arXiv preprint arXiv:2507.08065, 2025a. arXiv:2507.08065 [qfin.RM]. Avishek Bhandari. ManyIVsNets: Environmental Phillips Curve Analysis with Multiple Instrumental Variables and Networks, 2025b. URL https://CRAN.R-project.org/package=ManyIVsNets. R package version 0.1.1, CRAN. Avishek Bhandari. compute-engine: Sandboxed open-source econometrics workbench (R) with an AI analyst chatbot. Software, https://github.com/avishekb9/compute-engine, 2026a. commit d2df994; live service https://shssm-compute-b7ui3oxaqq-el.a.run.app. Avishek Bhandari. econstellar: Research workbench and public portal. Software, https://github. com/avishekb9/econstellar, 2026b. commit 2d82493; live portal https://avishekb9.github. io/econstellar/. Avishek Bhandari. NEURICX: Network-enhanced universal real-time intelligence for complex eXchange. Software, https://github.com/avishekb9/NEURICX, 2026c. commit 8662f8f. Avishek Bhandari and Ipsita Parida. Scale-ordered contagion: A spectral theory of heterogeneous information adaptation in financial networks, 2026a. URL https://arxiv.org/abs/2606.04113. arXiv:2606.04113 [econ.EM]. Avishek Bhandari and Ipsita Parida. sochcontagion: Scale-Ordered Contagion: Spectral Theory and Tests of Heterogeneous Information Adaptation, 2026b. URL https://github.com/avishekb9/ sochcontagion. R package version 0.1.0. Avishek Bhandari, Ipsita Parida, and Hitesh Kumar Sahu. What drives contagion? identifying and attributing cross-border transmission mechanisms. arXiv preprint arXiv:2604.26546, 2026a. arXiv:2604.26546 [econ.GN]. Avishek Bhandari, Ipsita Parida, and Hitesh Kumar Sahu. contagionchannels: Two-Stage Detection and Attribution of Cross-Border Financial Contagion Channels, 2026b. URL https://CRAN. R-project.org/package=contagionchannels. R package version 0.1.3, CRAN. 12
Andrew C. Chang and Phillip Li. Is economics research replicable? sixty published papers from thirteen journals say “often not”. Critical Finance Review, 11(1):185–206, 2022. doi: 10.1561/ 104.00000053. Elizabeth R. DeLong, David M. DeLong, and Daniel L. Clarke-Pearson. Comparing the areas under two or more correlated receiver operating characteristic curves: A nonparametric approach. Biometrics, 44(3):837–845, 1988. doi: 10.2307/2531595. Francis X. Diebold and Kamil Yilmaz. Better to give than to receive: Predictive directional measurement of volatility spillovers. International Journal of Forecasting, 28(1):57–66, 2012. doi: 10.1016/j.ijforecast.2011.02.006. Wilson W. L. Fung, Ivan Sham, George Yuan, and Tor M. Aamodt. Dynamic warp formation and scheduling for efficient GPU control flow. In Proceedings of the 40th Annual IEEE/ACM International Symposium on Microarchitecture (MICRO), pages 407–420. IEEE, 2007. doi: 10. 1109/MICRO.2007.30. Ramazan Gençay, Faruk Selçuk, and Brandon Whitcher. Multiscale systematic risk. Journal of International Money and Finance, 24(1):55–70, 2005. doi: 10.1016/j.jimonfin.2004.10.003. Alexander Kraskov, Harald Stögbauer, and Peter Grassberger. Estimating mutual information. Physical Review E, 69(6):066138, 2004. doi: 10.1103/PhysRevE.69.066138. M. E. J. Newman. Modularity and community structure in networks. Proceedings of the National Academy of Sciences, 103(23):8577–8582, 2006. doi: 10.1073/pnas.0601602103. C.-K. Peng, S. V. Buldyrev, S. Havlin, M. Simons, H. E. Stanley, and A. L. Goldberger. Mosaic organization of DNA nucleotides. Physical Review E, 49(2):1685–1689, 1994. doi: 10.1103/ PhysRevE.49.1685. Donald B. Percival and Andrew T. Walden. Wavelet Methods for Time Series Analysis. Cambridge University Press, 2000. ISBN 978-0521685085. Geir Kjetil Sandve, Anton Nekrutenko, James Taylor, and Eivind Hovig. Ten simple rules for reproducible computational research. PLOS Computational Biology, 9(10):e1003285, 2013. doi: 10.1371/journal.pcbi.1003285. Thomas Schreiber. Measuring information transfer. Physical Review Letters, 85(2):461–464, 2000. doi: 10.1103/PhysRevLett.85.461. James Theiler, Stephen Eubank, André Longtin, Bryan Galdrikian, and J. Doyne Farmer. Testing for nonlinearity in time series: The method of surrogate data. Physica D: Nonlinear Phenomena, 58(1–4):77–94, 1992. doi: 10.1016/0167-2789(92)90102-S.
13