Research & Deep Interests
The areas of AI I keep coming back to
The rest of this site is in my words, his AI. This page is different — here Pranav takes over and goes deep himself, in his own voice.
My MSc in AI at MTU Cork was not just a qualification — it was a set of disciplines that genuinely changed how I reason about systems, problems, and uncertainty. Add a few side quests that never left me, and you get the map below. The further I get from graduation, the more I find myself applying these ideas as an architect — in production software, enterprise products, and my own startups.
Computer Vision
Thesis domain · real-time perception systems
Computer vision asks a deceptively simple question: how do you turn raw pixels into meaning? My MSc thesis answered a specific version of it — can we detect student engagement in a classroom using only a standard webcam?
Thesis — Student Engagement Detection
The system used OpenFace 2.0 to extract three signals from each video frame: head pose (pitch, yaw, roll), gaze direction (where the eyes are pointing), and facial action units (the 44 standardised muscle movements that encode expression). A classifier then mapped these signals to engagement levels in real-time.
What made it interesting was the failure modes. Lighting changes corrupt facial action units. Glasses scatter gaze estimation. Learners from different cultural backgrounds express attention differently. A system that works in a controlled lab fails in a real classroom — which is exactly the kind of gap between demo and production that I now think about in every AI system I build.
Webcam frame
|
v
+--------------+
| OpenFace 2.0 | extract signals, every frame
+------+-------+
|
+------+--------------+
v v v
Head Gaze Facial Action
Pose Direction Units (44 muscles)
+------+--------------+
|
v
+--------------+
| Classifier |
+------+-------+
|
v
Engaged . Neutral . Distracted3D Scene Reconstruction — KLT Optical Flow
Tracking feature points across frames using the Kanade-Lucas-Tomasi algorithm, then using the motion parallax between matched points to reconstruct scene geometry. Camera calibration via checkerboard patterns to go from pixels to real-world coordinates.
SIFT-Inspired Feature Descriptor — Built from First Principles
Implementing the full Scale-Invariant Feature Transform pipeline without a library: Gaussian blur scale-space, DoG interest point detection, dominant orientation assignment, and a 128-dimensional descriptor for matching across images under rotation and scale changes.
Where this could live
Visual quality inspection, document and identity verification, object detection pipelines — any system that turns a camera feed into a decision. The deeper value of the MSc work was understanding the math, not just callingcv2.detectAndCompute(). That makes it much easier to know when a pre-trained model will fail.
Knowledge Representation & Planning
Reasoning under uncertainty · formal world models
Before machine learning became the dominant lens, AI was largely about representing what a system knows — formally, precisely, and in a way that supports reasoning. Knowledge Representation and Planning (KR&P) deals with how to encode entities, relationships, rules, and assumptions about the world so that a system can draw conclusions, make decisions, and revise its beliefs when new information arrives.
This is not an academic curiosity. It is the foundation of every system that does more than classify inputs — every system that needs to reason.
Project — Mars Rover: Exploring for Water
The rover has a mission: explore Martian terrain and locate water sources under a constrained energy budget. The system does not learn from data — it reasons from a formal knowledge base.
+-----------------------------+
| KNOWLEDGE BASE |
| terrain . water signatures |
| passable cells . rules |
+-------------+--------------+
| informs
v
+-------+ +---------+ +--------+ +------+
| SENSE |-->| UPDATE |-->| PLAN |-->| ACT |
| probe | | beliefs | | search | | move |
+---^---+ +---------+ +--------+ +--+---+
| |
+-------------- observe <-----------+Where KR shows up in production AI — three real applications
AI Guardrails
Constitutional AI and semantic guardrails are essentially a knowledge base of constraints — rules the system must never violate, regardless of what the generative model wants to produce. A guardrail system is a KR system: it encodes permissible behaviours, checks outputs against them, and rejects or reroutes on violation. The same formal machinery from the Mars rover applies to keeping LLMs safe in production.
Recommendation systems (Wynoot)
A naive recommendation system learns from co-occurrence. A knowledge-augmented one knows that a user who books a 60-minute deep tissue massage prefers evening slots, has a price sensitivity around a certain range, and has previously chosen the same therapist. Encoding this as a knowledge graph — with nodes for users, services, time preferences, and constraints — enables recommendations that are explainable, not just statistically correlated. This is the direction Wynoot's AI recommendation layer is taking.
LLM agent tool selection
When an AI agent decides which tool to call next — MCP server, API, database — it is doing a form of planning under a knowledge base of tool capabilities and preconditions. The architecture of reliable agent systems benefits enormously from KR thinking: formal tool schemas, explicit preconditions, and verified post-conditions reduce unpredictable behaviour.
Metaheuristic & Combinatorial Optimization
personal favourite · NP-hard problems · elegant solutions to impossible spaces
Most problems that matter in the real world are NP-hard. There is no polynomial-time algorithm that finds the perfect solution. The solution space is combinatorially explosive — for a routing problem with 50 stops, there are more possible orderings than atoms in the observable universe. Exact methods fail.
This is where metaheuristics live. Rather than searching exhaustively, they guide a search process intelligently — accepting imperfection, avoiding local traps, and finding solutions that are very good rather than provably optimal. The elegance is that the best algorithms are often inspired by nature.
Genetic Algorithms — the one I built
Inspired by biological evolution. You maintain a population of candidate solutions (not one solution, but many — diversity is the whole point). Each generation, better solutions are selected more often to reproduce. Crossover combines two parent solutions to create offspring that inherit traits from both. Mutation introduces small random changes to prevent stagnation. Over hundreds of generations, the population converges toward high-quality solutions.
The lesson that stayed: diversity in a population prevents getting stuck. Too much selection pressure and everyone converges on a local optimum. Too little and nothing improves. The right balance between exploration and exploitation is a design problem, not a parameter to tune blindly — and it maps directly to how I think about technical architecture decisions.
Initialise population
(random valid tours)
|
v
+--> Evaluate fitness --------+ shorter tour = fitter
| (total distance) |
| v
| Selection (tournament)
| |
| v
| Crossover (PMX, valid perms)
| |
| v
| Mutation (swap two cities)
| |
+-----------------------------+
repeat ~200 generations
|
v
Near-optimal routeOther metaheuristics worth understanding
Simulated Annealing
Inspired by the controlled cooling of metals. The algorithm occasionally accepts a worse solution — with a probability that decreases as a "temperature" parameter drops. Early in the search, it wanders freely. As temperature falls, it becomes increasingly greedy. This escapes local optima that purely greedy search cannot. The cooling schedule is the art.
Ant Colony Optimization
Ants find the shortest path to food through pheromone reinforcement — shorter paths accumulate pheromone faster because ants traverse them more frequently. The algorithm models this: artificial ants probabilistically build solutions, pheromone trails are updated proportionally to solution quality, and evaporation prevents premature convergence. Excellent for routing and scheduling.
Particle Swarm Optimization
A swarm of particles moves through the solution space, each remembering its own best-found position and the swarm's global best. Velocity updates pull each particle toward both. Elegant for continuous optimization — particularly useful in neural architecture search and hyperparameter tuning.
Where combinatorial optimization shows up in production — and in my work
Wynoot scheduling
Booking optimization is a constraint satisfaction + scheduling problem: therapist availability, room capacity, service duration, client preferences, minimising gaps. Exact solvers break down at scale. Metaheuristics find good schedules fast.
API call sequencing
In complex integrations, the order of API calls affects latency, error recovery, and cost. Finding the optimal sequence under dependency and retry constraints is a combinatorial problem disguised as engineering.
Fraud rule ordering
Anti-fraud rules applied in the wrong order miss signals or trigger false positives. The optimal evaluation order — given rule cost, catch rate, and volume — is a sequencing problem that benefits from search heuristics.
LLM hyperparameter search
Prompt templates, temperature, chunk size, retrieval top-k — the joint search space for a RAG pipeline is vast. Bayesian optimization (a cousin of metaheuristics) navigates it efficiently.
Deep Learning & NLP
CNNs · transfer learning · dialogue systems
Deep learning is the domain most people enter AI through today. I came to it already knowing how feature extractors worked from the computer vision work — which means I never had to treat neural networks as magic. Understanding what a convolutional filter is actually doing makes it much easier to know when to use pre-trained features versus training from scratch, and why.
CNN Image Classification
Built a flower classification system comparing two approaches: training a CNN from scratch vs. fine-tuning a pre-trained model (transfer learning). The result confirmed what the literature says — transfer learning wins for small labelled datasets because the lower layers (edge, texture, colour detectors) are already learnt. But building from scratch teaches you exactly why that is, which matters when you need to make architectural decisions on novel problems.
Personality-Driven Dialogue System
Built an NLP chatbot that went beyond intent-response mapping — the system maintained a personality model that shaped how it responded, not just what it said. Speech-to-text input (live microphone) + intent classification + dynamic response generation based on personality parameters. An early exploration of what would later become the prompt engineering and persona work in modern LLM systems.
Pre-trained CNN (learned on millions of images)
+---------+---------+---------+------------+
| edges | texture | shapes | classifier |
+---------+---------+---------+------------+
\_________ keep (freeze) ________/ \__ retrain
these layers already know vision on your classes
From scratch: must learn edges AND your task -> needs huge data
Fine-tuning: reuse vision, learn only task -> wins on small dataWhere this connects now
LLM orchestration, RAG pipelines, and AI agents are the current frontier — but the underlying instincts are the same: what does the model actually know, what does it hallucinate, and how do you design the system so that failure is recoverable? The MSc work on CNNs and NLP built the mental models. Enterprise systems and Wynoot stress-test them in production.
Decentralized Systems & Blockchain
2019 hackathon · trust as infrastructure · a use case I still think about
Not every favourite project comes from a classroom. At a 2019 hackathon, a small team and I built a food traceability system on Hyperledger Fabric — a permissioned blockchain. The question was simple and the implications were not: can you prove where your food actually came from?
Hackathon — Farm-to-Fork Traceability
In a normal supply chain, every actor keeps their own records. When something goes wrong — contamination, fraud, a broken cold chain — nobody can reconstruct the full history quickly, and everyone can quietly edit their own version of events. A shared, tamper-proof ledger removes that ambiguity. Every handoff from farm to processor to distributor to retailer becomes a signed, timestamped transaction that all parties can see but none can rewrite.
We chose Hyperledger Fabric over a public chain deliberately — supply chains need known, permissioned participants and private channels, not anonymous miners. That choice itself is the interesting architecture lesson: the technology must fit the trust model of the actual problem.
Farm --> Processor --> Distributor --> Retailer --> You
| | | | |
v v v v v
+------------------------------------------------------+
| Hyperledger Fabric - shared tamper-proof ledger |
| every handoff = a signed, timestamped transaction |
+------------------------------------------------------+
| scan QR at any point
v
"This mango: farm in Ratnagiri, picked 4 days ago,
cold-chain unbroken, zero tampering events."Where my head goes next — the smart fridge
It was relevant in 2019. It is more relevant now. Trace the source far enough and it stops being about tracking and starts being about intelligence: a fridge that knows what is inside it, where each item came from, when it will spoil, and what you can cook before it does. Provenance data plus a few sensors plus a recommendation layer — suddenly the boring ledger becomes a everyday product. That jump, from infrastructure to lived experience, is exactly the kind of leap I find irresistible.
The honest reason this stuck: I love use cases where trust, transparency, and the physical world meet code. That instinct shows up everywhere in my work — in anti-fraud systems, in API governance, in how I think about AI guardrails. Different domains, same value.