Explore Projects

The Liquid Galaxy ecosystem currently faces an unstructured and fragmented onboarding process. Crucial development information is scattered across various wikis and forums, leading to a steep learning curve and persistent architectural rule violations by new developers. Furthermore, the absence of an interactive sandbox makes it difficult for contributors to safely experiment with code and receive instant feedback, while advanced capabilities like 3D KML modeling remain heavily underutilized due to a lack of guided, hands-on tutorials. LG Interactive Onboarding radically overhauls contributor training by transforming the Liquid Galaxy rig itself into an immersive, interactive classroom. Operating on a "phone-as-driver, rig-as-canvas" philosophy, the system uses a smartphone application as a remote control to project educational content, live code exercises, and data visualizations directly onto the rig's 5-screen panoramic display. The platform integrates multi-modal learning—combining animated visual diagrams, auditory voice narration, and kinesthetic hands-on coding—with a privacy-conscious, on-device Gemini AI Mentor. This enforces core development best practices from day one and significantly reduces the manual onboarding workload for organization mentors.

This project proposes integrating NVIDIA's Thrust parallel algorithms library with HPX to enable GPU acceleration while maintaining consistency with HPX's existing parallel algorithm interfaces. The solution involves creating a specialized Thrust executor that extends HPX's CUDA executor capabilities, implementing automatic memory management for data transfers between host and device, and developing a dispatching mechanism that selects the appropriate backend (CPU or GPU) based on execution policies. Key technical components include a version-aware API layer to handle Thrust compatibility, exception handling that bridges Thrust/CUDA errors with HPX's error system, and template-based algorithm overloads that transparently route calls to Thrust implementations when GPU execution is requested. The implementation will proceed through four phases: establishing core infrastructure (executor, memory management), integrating fundamental algorithms (transform, reduce, sort), adding HPX execution policy support, and concluding with comprehensive testing and optimization. The resulting system will allow developers to write single code paths that automatically leverage GPU acceleration through Thrust when available, all while maintaining HPX's asynchronous execution model through future-based interfaces.

Modern printer testing remains heavily dependent on physical hardware, making it slow, expensive, and difficult to scale for regression testing. While OpenPrinting already provides a Go-based MFP simulator and a Python-based image evaluation framework, these components are not yet integrated into a unified, automated testing system. This project proposes to build an end-to-end, hardware-free print testing pipeline that bridges this gap. The system will be implemented as a Go-based orchestration tool that directly leverages the simulator’s internal libraries for efficient control, while embedding Python to execute advanced image evaluation. It will automatically load printer models, create CUPS queues, enumerate all supported print modes, execute print jobs, capture simulator outputs, and evaluate them against expected results. The pipeline will support both single and batch testing modes, enabling scalable regression testing and seamless CI/CD integration. It will generate detailed, structured reports with quality metrics (e.g., SSIM, PSNR) and pass/fail analysis. By transforming isolated components into a cohesive, automated system, this project will significantly enhance reliability, reproducibility, and scalability of printer testing in the OpenPrinting ecosystem.

This project develops a high-precision, clinically viable pipeline for segmenting Coronary Artery Calcium (CAC) from non contrast cardiac CT scans using the Stanford COCA dataset. The core innovation is a Hybrid 3D U Net architecture that balances the local inductive bias of CNNs with the global context of Transformers, specifically optimized for the extreme sparsity of calcified lesions. The architecture integrates 3D Deformable Attention to bypass O(N^2) scaling and CoordConv for anatomical grounding, effectively suppressing false positives from osseous structures like ribs. A primary research contribution is the experimental Fourier Neural Operator (FNO) bottleneck, which tests the hypothesis that calcified plaques can be isolated as high-frequency signals in the spectral domain. To ensure clinical utility, the model is trained using Scoring-Driven Consistency (SDC) a differentiable volume score loss that aligns optimization with the Agatston metric. Deliverables include a MONAI based preprocessing pipeline, a rigorous benchmark against an nnUNet gold standard, and a fully automated Agatston scoring engine for risk categorization (0, 1–99, 100–399, ≥400). This work aims to bridge the gap between architectural novelty and real world diagnostic accuracy for cardiovascular risk stratification.

The investigation of symmetries has long been a cornerstone in analyzing physical systems. As formalized by Noether’s theorem, conserved quantities are inherently linked to the symmetries present within the system. In high-energy physics, the study of symmetries has played a key role in shaping the Standard Model, which elucidates three of the four fundamental forces in nature. Recent research has showcased the efficacy of Equivariant Quantum Neural Networks (EQNNs) in leveraging symmetries within variational quantum machine learning (VQML), thereby augmenting model performance and efficiency. This project is dedicated to building Equivariant Quantum Neural Networks (EQNN) and Equivariant Hybrid Quantum-Classical Neural network architectures that leverage symmetries commonly present in image data, specifically roto-reflection symmetries. By incorporating symmetries such as rotations and reflections into the quantum neural network’s design, we can significantly reduce the number of trainable parameters, thereby decreasing the model’s complexity and improving its efficiency. This method enhances learning capabilities with smaller datasets while also promoting better generalization. We evaluate the performance of our model using standard benchmark datasets for image classification and compare it against other quantum models.

Integrating AI agents with databases today requires custom implementations for each framework—no standard exists for capability discovery, safe query execution, or persistent context across sessions. This project adds agent compatibility to Apache AsterixDB by implementing two emerging standards: the Model Context Protocol (MCP) for structured tool exposure and the Agent-to-Agent (A2A) protocol for multi-agent coordination, along with persistent agentic memory utilizing AsterixDB's native storage. Key deliverables include: McpServlet implementing JSON-RPC 2.0 protocol with tools/list, tools/call, and resources/read methods; ToolRegistry enabling dynamic capability discovery; QueryTool and SchemaTool exposing SQL++ execution and dataset introspection; rate limiting and query safeguards for production safety; AgentMemoryManager providing durable CRUD storage for session context via SQL++ datasets; MemoryServlet REST endpoints for memory operations; and A2A protocol endpoints for multi-agent task delegation (stretch goal). The implementation integrates with existing AsterixDB infrastructure—BasicAuthServlet for authentication, MetadataManager for schema access, and LSM storage for persistence—requiring no breaking changes. By project end, AI agents can discover AsterixDB's capabilities, execute queries like "find customers with orders over $1000," and recall previous interactions across sessions—transforming AsterixDB into an AI-native database that speaks the language of modern agent frameworks.

FinBot CTF is OWASP's premier learning environment for agentic AI security, yet it currently operates solely as an offensive arena. Practitioners can exploit vulnerabilities but lack the capability to implement, test, and score defenses against the OWASP Agentic Top 10. This project closes the blue-team loop by introducing a production-inspired, hook-based security framework. The solution is a four-part architecture: (A) a pluggable Guardrail & Detection Framework with pre-tool, post-output, and pre-action hooks that emit a standardized security event model; (B) a Defense-Enabled Challenge Pack converting 3-5 existing offensive challenges (A2: Excessive Agency, A3: Memory Poisoning, A8: System Prompt Leakage) into paired red/blue tracks with integrated defensive scoring; (C) an MCP-Style Scenario Module featuring benign and malicious JSON-RPC tool servers, with detectors for output poisoning, prompt injection via payload, and unauthorized endpoint redirects; and (D) comprehensive Documentation & CI including Docker Compose, contributor guides, and a GitHub Actions test suite. This work transforms FinBot into a complete AI security training platform. Leveraging my prior contributions to the codebase, I will deliver a low-risk, high-impact implementation that equips defenders to build, test, and validate guardrails against real-world agentic threats, solidifying FinBot's role as the practical counterpart to the OWASP Agentic Top 10.

Stochastic dynamical systems play an important role in scientific and engineering domains, particularly in systems governed by Brownian motion or subject to random perturbations from the environment. Stochastic Differential Equations (SDEs) and Stochastic Partial Differential Equations (SPDEs) provide a mathematical framework to describe such complex stochastic behaviour. Understanding the hidden physics within these systems is pretty much essential for analyzing their stochastic and nonlinear dynamics. The NeuralPDE package in the SciML ecosystem currently lacks documentation for its existing SDE Physics-Informed Neural Network (PINN) solver and does not yet support multidimensional SDEs and SPDEs. This project aims to document the existing solver while also extending it to include PINN solvers for multidimensional SDEs based on the Wiener expansion, which expresses stochastic solutions as spectral expansions in terms of a set of random basis functions. The proposed SDE PINN solver uses the Kosambi-Karhunen-Loève (KKL) expansion for the Wiener process to obtain finite-dimensional approximations, effectively transforming SDEs into rough path ODEs. These ODEs can then be solved using the standard loss function formulation of PINNs for ODEs. As a natural extension, this approach can be generalized to SPDEs using the Polynomial Chaos Expansion (PCE), which extends the Wiener expansion to handle spatially distributed noise in stochastic systems. By developing and implementing these solvers, this project aims to enhance NeuralPDE's capabilities in solving high-dimensional stochastic systems, making it a more comprehensive tool for data-driven modelling and simulation of stochastic dynamical systems.

Fineract is largely used as a system of record for lending in many institutions globally. As such, most of the analysis is about portfolio health — how well are people paying back, and what are the key risks around repayments. This includes PAR, loan loss provisioning, write-offs, and trend lines for the same, along with basic stats like number of customers, the loan cycle they are on, aging of customer cycles, exceptions tracking, and correlation to any characteristic in the data. Currently Fineract does not have a analytics pipeline where vendors, users, institution can see these analytics. This project solves this problem. My plan is to build a complete ELT analytics platform. A python extractor will pull data from read replica of Fineract DB incrementally using a read only database user. It will push the data the PostgreSQL analytics warehouse. From there a dbt project will handle all the data transformation (delinquency calculations, PAR ratios, repayment behavior, portfolio health). I will show interactive dashboards with different type of charts, graphs, stats and analytics using Apache Superset. By the end of GSoC, the deliverables are: a working Python ELT extractor with both backfill and incremental modes, a fully tested 4-layer dbt warehouse model covering the Fineract lending domain, five production-oriented Superset dashboards (Portfolio Health, Delinquency and PAR, Repayment Behavior, Risk and Finance, Customer Lifecycle), Docker Compose setup so anyone can run the full stack locally, and complete documentation including a runbook and data dictionary. The whole stack is Apache 2.0 licensed, self-hostable, and designed so future contributors can add new analytics modules without changing what's already there.

Sugar Activity on Demand addresses a key barrier in Sugar Labs: the difficulty learners face in creating their own activities due to the need for programming knowledge. This limits access to constructionist learning, where students learn best by building meaningful projects. This project introduces an AI-assisted system that allows learners to describe an activity in natural language and receive a fully functional, installable Sugar activity. The system combines a model-agnostic LLM pipeline, a retrieval-augmented knowledge base built from real Sugar Activity source code, and an AST-based validator to ensure that generated Python code is both correct and safe. Activities are generated with proper GTK3 interfaces, toolbar integration, and Journal support, ensuring they are fully compatible with the Sugar ecosystem. Beyond generation, the project emphasizes learning through a Reflective Studio, where learners explore, understand, and modify the generated code. Using scaffolded challenges, inline annotations, and reflection prompts, the system follows the constructionist Use → Modify → Create progression, enabling learners to gradually take ownership of their creations rather than passively consuming generated output. Deliverables AI-powered activity generation pipeline (prompt → plan → code → installable bundle) RAG-based knowledge system using real Sugar Activity examples AST-based security validation and safe code generation framework Interactive Reflective Studio with guided editing, annotations, and challenges Integration into Sugar’s Home View with a seamless “Create with AI” entry point Support for iterative refinement, version history, and sharing via the Sugar Journal This project aligns with Sugar Labs’ constructionist philosophy by transforming AI from a passive generator into an active learning partner, empowering learners not just to use software, but to understand and create it.

In this project we want to generate disparity map and depth information from multiple 360-degree Images that can be helpful 3D scenes reconstruction.  I will focus on deep learning based depth map inference. I will model and train current state-of-the-art models with Tensorflow/Pytorch and compare their performance. I will convert the best performing model to ONNX representation which the DNN module (OpenVINO) can infer from. Thus integrating the model into libXcam for 360-degree depth map inference.

The proposal outlines a comprehensive plan to enhance the model's accuracy and efficiency, coupled with new user interface (UI) integrations. First, the optimization of machine learning and statistical models will focus on Exploratory Data Analysis (EDA), feature reduction, feature engineering, and employing better imputation techniques for handling missing data. This will streamline the process and improve model performance. Additionally, fine-tuning a rule-based system will involve adjusting and normalizing feature weights, alongside providing users with tailored recommendations based on our analysis. Another key objective is the integration of new datasets. Currently, each dataset requires different handling, and by incorporating a new dataset, we aim to deliver more refined insights. To address data imbalance, techniques such as minority class upsampling and additional data generation methods will be applied. This ensures the model can better handle unbalanced data distributions. Fraud detection is also a critical focus, with plans to identify suitable datasets and initiate the development of robust fraud detection capabilities. Lastly, improvements in federated learning will be made to ensure data privacy and efficiency, allowing the model to learn from decentralized data without compromising individual data security.

<p>Meshery Models are declarative representations of infrastructure and applications. Within these models, Relationships define how different Components (e.g., Kubernetes resources, Cloud services) interact and depend on each other. These relationships are crucial for visualizing, understanding, and managing complex cloud native systems. This project focuses on expanding Meshery Relationships across a wide range of technologies, including Kubernetes and major cloud providers, to better model their interactions and improve user insights. There is a growing need to accurately model these relationships to provide better insights and control over deployments.</p><p><br></p><p>&nbsp;The next phase focuses on Cloud Solution Architecture through workload design by creating and publishing Meshery designs that use the newly developed relationships to represent real-world deployments. These designs will be turned into structured tutorials with hands-on labs using Meshery Playground, offering step-by-step guidance and interactive learning. All content will be reviewed by maintainers and published in Meshery’s official documentation</p><p><br></p><p>Responsibilities:</p><p>&nbsp;- Research and Analyze Technologies: Dive deep into various cloud-native technologies (e.g., different compute services, databases, messaging systems, network services, etc.) to understand their components and how they interconnect.</p><p>&nbsp;- Develop Relationship Definitions: Create and contribute relationship definitions, typically in JSON or YAML format, to the Meshery models.</p><p>&nbsp;- Model Inter-Technology Interactions: Focus particularly on defining relationships between components from different technologies (e.g., how a Kubernetes deployment relates to an AWS RDS instance, or how a Linkerd service interacts with a Prometheus monitoring component).</p><p>&nbsp;- Document New Relationships: Clearly document the newly defined relationships, their purpose, and how they are represented within Meshery designs, contributing to the official Meshery documentation.</p><p>&nbsp;- Create and publish designs that use newly developed relationships.</p><p>&nbsp;- Create and publish hands-on tutorials using Meshery Playground, featuring step-by-step guides and interactive labs that enable learners to apply concepts without the hassle of any configuration.</p><p><br></p><p>Expected Outcome:</p><p>&nbsp;- A multitude of new intra- and inter-service relationships defined across AWS, Azure, and GCP.</p><p>&nbsp;- Creation and publishing of real-world workload designs that represent cloud solution architectures using the newly defined relationships.</p><p>&nbsp;- Tutorials reviewed by various project maintainers and then published in guides/tutorials.</p><p>&nbsp;- Policy Contribution: For advanced interns, there may be opportunities to contribute to the Rego policies that evaluate and enforce these relationships.</p><p><br></p>

<p>The CDGen is an application using Eclipse APP4MC for code generation using the System Model to enhance cost-effectiveness and decreasing the chance of errors when compared to manual coding. The main outputs of this application are C and Header files which hold all the details of the model for the compilation and building process(generating executables for running on the Processor). Based on the Eclipse Modeling Framework, its capabilities not only include hardware and software modeling but in addition, tools for visualization and processing. The application will be added to the set of tools of Eclipse APP4MC.</p>

In Hyperledger Fabric, there can be a significant mismatch between the simple key-value ledger storage abstraction and the data representation style used for developing chaincode – i.e., Java has classes and objects, not keys and values. Currently, there aren’t really good tools for facilitating the “object-key-value mapping” (at least anything approaching classic Object-Relational Mapping – ORM). This not only complicates chaincode development, but a less than systematic approach with the mapping can lead to performance problems (through logically unnecessary MVCC conflict transaction invalidations). Additionally, an explicit object-oriented ledger data model would enable imposing data-centric constraints on the ledger content, either for runtime checking or development time verification and validation. The goal of the mentorship is to design and implement an object-key-value mapper with the following functionality: - Generating key-value storage models from UML ledger data models - Application of storage strategies during the mapping (as we explored in the report referenced below) - Generating a chaincode-internal Java data access/persistence layer, “parameterized” by the storage model - Demonstration on a representative example (e.g., our earlier work on faithfully implementing TPC-C to Fabric) - (If we have time): declaring OCL (Object Constraint Language) constraints on the models and enforcing them in the data access layer

In this project, we aim to build a Rust-based log processing framework. Applications built on this framework will be compiled into WebAssembly and run in WasmEdge containers side by side with Linux containers and apps. The WasmEdge app collects logs from other containerized apps and then sends them to a streaming database or processing pipeline. - Expected outcome: * Create a Rust framework with 3 traits similar to the [`Transformer`](https://github.com/second-state/MEGA/blob/main/mega_etl/src/lib.rs#L99) trait in the [MEGA framework](https://github.com/second-state/MEGA). * The `Collector` trait abstracts operations needed for a log collector. * The `Transformer` trait abstracts the transformation algorithms that can be applied to the logs. * The `Destination` trait abstracts operations needed to send transformed to a streaming data pipeline or database. * Implement at least two `Collector`s. One for MySQL database binlog and the other for a generic log file in a Linux container in the same Kubernetes pod. * Implement at least two `Transformer` algorithms supported by [FileBeat](https://www.elastic.co/guide/en/beats/filebeat/current/filebeat-overview.html). * Implement at least three `Destination`s. One for a Kafka queue, one for a Redis database, and the other for ElasticSearch. * Provide CI and demo test cases. * Provide documentation and tutorials.

<p>In this project, I will be building a unity plugin that runs the MediaPipe Holistic model to do animation of a rigged 3D model as shown on this link. The Holistic model is indeed a great model by MediaPipe. Over a period, I have noticed a sudden rise in its demand in Unity XR projects since it provides the accuracy, FPS and features that no other competitor possesses. As of current technology, this can be still implemented with unity barracuda or TensorFlow or posenet. But none of these technologies is having support for cross-platform and mobile development having a decent FPS on an average device.</p>

Current Frontier LLMs are really bad at assisting with writing JAX code due to the sparse resources spread across multiple different forums and platforms which are often inacessible/unscrapeable (such as discord) by conventional search engine indexers or web scrapers. Thus they usually do not make it into the final pretraining datasets, hurting frontier models' performance on those frameworks. I want to fine-tune OSS models on JAX code, where the data is manually scraped/collected by hand from diverse sources like YT talks, GitHub discussions, Books & Papers and even XLA HLO dumps to enhance the models' understanding of the compiler internals and improve debugging capabilities as well as better guide the developers when dealing with the internals. Another key focus would be incorporating commonly-used popular libraries like Equinox, Optax and Scalax as well because current SOTA LLMs are not familiar with these (relatively) niche but handy libraries and thus prove to be less helpful and prone to hallucinating components of the ecosystem that don't exist. This pretrained model will be available externally through an API or a CLI interface like Aider/Claude Code styled wherein it'd be accessible to everyone regardless of their development environment or IDE/Editor. I would also experiment with new ideas such as integrating type-annotations, Array and PyTree shape annotations and packaging other auxiliary information embedded in the AST to provide further context to the model apart from the raw code itself.

This project aims at incorporating Physics informed neural network (PINN) based ODE solvers into the Diffusion probabilistic models(DPM) , to build a fast and efficient sampler for high dimensional complex probability distribution. Diffusion models are characterized by a probability flow ODE equation which needs to solved using numerical solvers to generate samples from the target probability distribution. In this project we replace the numerical ODE solvers with PINNs which are trained to represent the solution of the probability flow ODEs over a domain of values. This enables us to amortize the large upfront cost of training PINN to fast sampling speed once the model is trained. Different variants of PINN like models with hard constrains on initial/boundary conditions, augmented Lagrangian based models, can-PINN and neural operator based methods will be systematically tested on different non Gaussian 3D probability distribution like [ Mixture of Gaussian, 3D helical, Torodial distribution and Concentric spherical shells ]. I will be testing both single objective optimization and multi objective optimization techniques to handle the physical loss term and MSE loss term in PINN training. A systematic analysis of different variants of PINNs to solve the probability flow ODE will be presented with metrics to quantify the PINN representation error and comparison between the true probability distribution and samples from PINNDE. Depending on the viability of the results on the above mentioned tests, PINNDE method will be used on the fast colorimeter simulation challenge 2022 benchmark dataset 1.

<p>This project will convert some pre-trained Keras models into TensorFlow js models and explains how they can be made accessible by packing them in npm packages. Additionally, a model that is mobile-ready will be created and trained for skin cancer prediction. This model will then be made available over an npm package for other developers to use it in their applications. Furthermore, the neural style transfer will be implemented in TensorFlow js to enable a completely client-side based style transfer. This is interesting for privacy aspects because the image will only be processed locally and not uploaded to a server.</p>

Neural networks are descendants of McCulloch & Pitts' threshold-based mathematical model of a binary neuron, but there is ample evidence that unicellular organisms are capable of relatively complex maze navigation and other cognitive tasks, indicating information-processing capabilities in cellular subsystems. The task is to develop a computational model of elementary processing of analog information using Schrödinger's wave equation and Pilot Wave theory, leveraging the fact that a quantum wave function has multiple valid solutions and only one of them manifests. In Bohm & Hiley's elaboration of Pilot Wave theory, the Quantum Hamilton-Jacobi Equation can be decomposed into a classical component and a quantum component, the quantum potential. Most of the energy is in the classical component, but a small part of it is in the quantum potential. As the energy in the quantum potential is informed by and responds to the shape of the quantum wave, the process creates new information, expressed in the trajectory of the particle. The trajectory will help us take decisions. We propose two techniques, Statistical approach and Instantaneous approach. Both of the approaches use Pilot Wave theory since it is causal. For Statistical approach we will model the double slit experiment with Bohmian mechanics. The slits shape will depend on the input. We will pass many particles through the slit and take decision based on the interference pattern produced and the trajectory of the particles. In the second approach we will model the FMO complex in Green Sulphur Bacteria. Our model of the FMO complex will be used for Binary classification. There will be multiple slits in this and we will use AI to find the dimensions and location of the slits. Based on the trajectory we will take decision.

<p>This project focuses on validating KubeEdge as an edge-native infrastructure for lightweight large language model inference. As more AI services move from the cloud to edge devices, lightweight LLMs provide a practical way to reduce latency, protect data privacy, and support local intelligence under limited resources.</p><p>The mentee will deploy one or more lightweight LLMs on KubeEdge edge nodes and evaluate the complete workflow, including model packaging, workload scheduling, service exposure, lifecycle management, and performance measurement.</p><p>The project is expected to produce a practical reference for running generative AI workloads on edge nodes managed by KubeEdge.</p><p><br></p><p>Expected Outcome:</p><p>&nbsp;- Successfully deploy and run one or more small-parameter large models on KubeEdge edge nodes, and complete end-to-end inference workflow validation.</p><p>&nbsp;- Explore deployment methods and best practices for managing lightweight model services based on KubeEdge.</p><p>&nbsp;- Evaluate basic performance on edge devices, including startup time, memory usage, inference latency, and runtime stability.</p><p>&nbsp;- Fix issues discovered during validation, and submit PRs to KubeEdge or related example repositories when necessary.</p><p>&nbsp;- Publish a blog or document to kubeedge/website introducing how to deploy and run small-parameter large models based on KubeEdge.</p><p>&nbsp;- Optional: complete example validation with a lightweight scenario, such as local Q&amp;A, document summarization, or lightweight multimodal inference.</p><p><br></p>

This project focused on developing ACUMEN (Active Cross-Entropy Method with Uncertainty-driven Neural ODEs), a data-efficient framework for system identification in healthcare. Unlike fixed or passive approaches, ACUMEN actively explores uncertain regions of physiological dynamics to accelerate learning. The goal was to build patient-specific models that can support adaptive therapies such as neuromodulation. At its core, ACUMEN couples Neural Ordinary Differential Equations (Neural ODEs) with Cross-Entropy Method Model Predictive Control (CEM-MPC). An ensemble of Neural ODEs serves as a surrogate model for continuous-time physiological signals. Ensemble disagreement quantifies epistemic uncertainty, which then drives exploration: CEM-MPC plans candidate interventions and prioritizes those that maximize model uncertainty, enhanced with optimistic rollouts, novelty-based objectives, and adaptive scaling. This iterative process collects the most informative data, retrains the ensemble, and progressively refines predictions. Key Deliverables: 1- A simulation pipeline using the RL-DBS environment to generate realistic EEG-like signals and stimulation effects. 2- A dataset of stimulation–response pairs across clinically relevant ranges. 3- A trained Neural ODE ensemble surrogate model with documented accuracy and uncertainty metrics. 4- An uncertainty-driven RL environment with CEM-MPC–based exploration. 5- Evaluation showing up to 24.2% error reduction and tighter uncertainty bands compared to random data collection. 6- Open-source code, documentation, and final report. Impact: By actively probing uncertain regions, ACUMEN reduces sample complexity and enables efficient, personalized system identification. This paves the way for safer, more effective closed-loop therapies in neuromodulation and beyond.