Research Fellow, RMIT University·Melbourne, Australia

Md Jahid Hasan

An applied AI researcher and engineer who ships systems designed to prove their own reliability, from peer-reviewed vision-language models to production multi-agent architectures.

I build the geospatial and agentic core of RMIT's Advanced Air Mobility analytics programme. Before that, an industry-embedded PhD with Carsales.com Ltd, where the vision-language system I designed went into production.

What I'm building

My work sits at the convergence of three tracks, and the interesting part is where they meet.

01 Computer vision

PhD × Carsales.com Ltd

CarDNetGroundingCarDDCarDVLM

+ CarDamageEval

Shipped to production

Case study 04

02 Data science

Research Fellow @ RMIT

Large-scale mobility&geospatial analytics on AWS

PySpark · Apache Sedona

In production

Try it live

03 Agentic AI

Build-in-public series

PromptProofAgentProofGroundProof

+ AssessAuto · CICDAgent

Shipped · more coming

Case study 01

Where I'm headed

Agentic systems that see and reason over data. Vision-language agents that inspect, verify, and act. Multi-agent workflows that orchestrate data pipelines, ground every claim in evidence, and prove their own behaviour through recorded, evaluated trajectories.

Live now — current work

Advanced Air Mobility, RMIT

RMIT School of Engineering · Feb 2026 – present

I develop the geospatial core of RMIT's Advanced Air Mobility analytics project — origin–destination models and mobility flow analysis across Australian regional geographies, built with PySpark and Apache Sedona over large-scale spatiotemporal datasets, running on EC2, EMR, Athena and SageMaker. I'm now designing a multi-agent orchestration architecture over that workflow with LangChain, LangGraph and the Claude Agent SDK, decomposing it into specialised agents for data ingestion, distributed OD extraction and demand estimation, and extending it to a delivery layer for visualisation, freight analysis and reporting under quality gates and human-in-the-loop checkpoints.

Three of the tools built on that pipeline are public and running right now. They're embedded below — not screenshots. Try them.

Localis Full Delivery OD Explorer (Jan 2026)

Released 2 Apr 2026 · Full one-month delivery dataset · Victoria

Device-level mobility data explored across Victoria on the full Localis delivery dataset for January 2026, rather than the sample — higher-fidelity OD analysis than the tool below. Three functions: OD passenger flows (top corridors by trip frequency and device count), temporal patterns (hourly distributions, weekday versus weekend), and distance-based corridor screening, which identifies long-distance corridors of 70 km or more as candidates for AAM feasibility analysis.

Loads the live Streamlit app in place. It may take a few seconds to wake.

Waking the app…

This is taking longer than usual — the app may be cold-starting, or this browser may be blocking the embed. Use the direct link below.

If the embed stays blank, the host is blocking framing — open it directly.

Open full app

All AAM applications

Selected work

Four builds, and the evidence for each

Three agentic systems, then the vision-language research they grew out of. All four share one discipline: build the system, then build the thing that proves the system works.

Case study 01 — Agentic engineering

The Proof series

Building an agent is cheap now. Proving it works is the skill.

An LLM system is easy to demo and hard to trust. Three projects, each documented publicly as it shipped, take that problem one layer at a time: first make a single output verifiable, then make a self-directing agent measurable, then take the runtime that came out of it and point it at a harder problem to see whether it holds.

Each stage builds on the last one's runtime. The third stage is graded by the harness the second stage produced — which is the actual claim being made here, that the evaluation machinery generalises rather than being written to flatter one demo.

01 · Stage one

PromptProof

Can I trust this output?

A self-correcting prompting engine that verifies information rather than assuming it. The demonstration task is a grounded claim checker: paste a paragraph, and the engine decomposes it into atomic claims, checks each against live web evidence, and returns Supported / Refuted / Unverifiable with a citation.

  • Prompt chaining — the task decomposes into extract → search → judge
  • Pydantic gate checks — every intermediate output is validated against a schema, with halt, retry, and retry-with-feedback logic
  • A gate-checked ReAct tool — the web-search call is itself schema-validated with controlled retry, so a broken observation can't corrupt the chain
  • Feedback loop — a rule-based evaluator reviews the finished report and loops until it passes or hits a cap

A RunTrace records every step, attempt, retry reason, token count and timing. The model client and the search transport are both injectable, so the whole engine runs against mocks for offline development.

The four mechanisms above come out of a structured study document in the Agentic-AI repo covering system and user prompts, role-based prompting, chain of thought, ReAct, prompt chaining, gate checks and feedback loops. It's the groundwork this stage was built from, not a separate project.

02 · Stage two

AgentProof

Can I trust a system that picks its own path?

A from-scratch agent runtime — no LangGraph, no CrewAI — at roughly 1,500 lines of readable Python, written specifically to expose the mechanics of an agent loop and prove they work rather than hide them behind a framework.

  • State-machine core — typed state in Pydantic, single-job steps, conditional routing, and a step budget so loops can never mean forever
  • Gate-checked tool use — arguments validated before the world is touched, responses validated before the model sees them; transient failures retry invisibly, permanent ones become structured errors the agent can reason about
  • Flight recorder — every run writes a crash-safe JSONL trace of thoughts, tool calls, observations, gate outcomes, token counts and timing; any run reconstructs fully from its file alone
  • Evaluation harness — golden datasets, rule evaluators across four dimensions (task completion, quality, tool interaction, system metrics), three lenses (final response, single step, trajectory), a bias-aware LLM-as-judge, and a CI regression gate
  • Trajectory viewer — any trace becomes a terminal story or a self-contained HTML report

90+ tests and the CI eval gate run fully mocked: no API keys, no network, no excuses for not verifying behaviour. Live model and live search are injected through the same interfaces the mocks implement.

What changed between stage one and stage two
PromptProof AgentProof
Core question Can I trust this output? Can I trust a system that picks its own path?
Control flow Fixed prompt chain, decided at design time State machine and router, decided at runtime
Observability Linear step log (RunTrace) Crash-safe, replayable trajectory and viewer
Quality enforcement At generation time — fixes this output At development time — a CI gate grades behaviour

03 · Stage three

GroundProof

Does the runtime hold up on a harder problem?

Retrieval-augmented generation that knows when facts expire and pays only for the context it needs. It is built on the AgentProof runtime — state machine, tool airlock, flight recorder, eval harness — and graded by it, which is the clearest evidence that stage two generalises rather than being a one-off.

  • Time-aware retrieval — every chunk carries an observed_at timestamp and every query runs "as of" a moment; conflicting facts resolve through deterministic supersedence rules where the later date wins and the older is kept as dated history, and answers must carry dated citations
  • Query-aware compression — between retrieval and synthesis, sentences are scored against the question and knapsack-packed into a token budget with per-sentence source attribution preserved

The full pipeline: adaptive router (none / one-shot / multi-hop) → temporal retrieval → retrieval grader gate, where weak evidence triggers a corrective fallback of reformulate, retry, then web search → supersedence resolver → context compressor → synthesis with mandatory dated citations. It runs fully offline by default, with no API keys and the corpus committed to the repo.

62%
fewer prompt tokens with evidence retention unchanged
The AgentProof runtime: a state machine of prepare, model call, router and tool executor, with the model client and tool transport injected from outside, every step written to a crash-safe JSONL trace, and that trace feeding both the viewer and the CI regression gate.
The AgentProof runtime. The model client and tool transport are injected, which is what lets the whole thing run against mocks with no keys and no network. Every run lands in the JSONL flight recorder, which feeds both the trajectory viewer and the CI eval gate.
The GroundProof pipeline: a question with an as-of date enters an adaptive router, then temporal retrieval, then a grader gate that either passes strong evidence on to the supersedence resolver and context pruner, or diverts weak evidence to a corrective fallback that reformulates, retries and falls back to web search.
Weak evidence never reaches synthesis. The grader gate diverts it into a corrective fallback instead, and the supersedence resolver settles conflicting facts by date before anything is written. Every answer carries dated citations.

Case study 02 — Vision × agentic

AssessAuto

One AI guesses the car damage. A multi-agent team over MCP proves it.

A single model asked to look at a damaged car and produce a price is making one unverifiable guess. AssessAuto is a multi-agent vision system that refuses to do that: every capability — detection, description, severity, price, fraud — is a separate, individually inspectable tool, so an assessment becomes a chain of typed steps you can replay rather than one opaque answer.

It is the clearest demonstration of what the agentic discipline in case study 01 buys you once the input is an image rather than text: a vision pipeline where every hop is typed, routed on demand, and recorded. The architecture has precedent in my earlier vehicle damage research; this is a clean, general-purpose rebuild of it.

  • A LangGraph supervisor running a ReAct loop and acting as a pure MCP client — it never calls any model directly
  • An MCP server exposing five tools, each a distinct model capability: detect_damage boxes the damage with a GroundingDINO + SAM detector on SageMaker; describe_damage annotates those regions and returns a typed per-region assessment; score_severity normalises it to a consistent 0–100 scale; estimate_price gives an AUD range with a repair-versus-replace call; and flag_fraud cross-checks the detector's regions against the description for inconsistencies. The last four are Claude on Amazon Bedrock.
  • Typed hand-offs between every agent step, never free text
  • Dual memory — a thread checkpointer for the live conversation and DynamoDB behind it, so follow-up questions don't need the photo re-uploaded
  • A replayable trajectory via OpenTelemetry-style spans
  • Selective invocation — the supervisor only invokes the tools a given question actually needs: a narrow "what damage is visible?" stops after describe_damage, while a full assessment runs the whole chain
5 tools each a distinct model capability, separately inspectable
Typed every hand-off, never free text
Replayable OpenTelemetry-style spans for the whole run
AssessAuto architecture: a LangGraph supervisor with a thread checkpointer and DynamoDB memory acts as a pure MCP client, calling one MCP server that exposes five tools — detect_damage on SageMaker, and describe_damage, score_severity, estimate_price and flag_fraud on Claude via Bedrock.
The supervisor never calls a model directly. Every capability is an MCP tool, so each can be inspected, swapped or tested on its own. Only detect_damage runs on SageMaker; the four reasoning tools are Claude on Bedrock.
A full AssessAuto run: the detector boxes a shattered windshield in purple, and the agents return an overall condition of SEVERE at 88 out of 100, notable damage including a deployed airbag, an AUD repair estimate broken down by cost driver, a consistency check finding no fraud indicators, and a plain-language recommendation.
One photo in, the whole chain out. Detection, severity, an itemised AUD estimate, a consistency check and a recommendation — with the agent trajectory expandable underneath. Sample photo from the public CarDD dataset.

Case study 03 — Agentic × the AAM domain

CICDAgent — Route Demand Assistant

An agent that cannot be deployed does not count.

A CI/CD pipeline whose centrepiece deploys an AWS Bedrock agent that estimates daily passenger demand on Australian routes. The choice of payload is deliberate, not incidental: it's the same demand-characterisation question as the Advanced Air Mobility work at the top of this page, shipped as production infrastructure — agentic engineering applied back onto my own research domain.

  • CI (ci.yaml, on pull requests to main) — lint and test in parallel, then build plus a Trivy vulnerability scan that fails on fixable HIGH or CRITICAL findings. No deploy.
  • CD (cd.yaml, on merge to main) — re-runs lint and test, builds a git-SHA-tagged image, pushes to ECR, deploys to staging with a smoke test, pauses for manual approval, deploys to production with a smoke test, then posts a Slack notification
  • Keyless AWS auth via GitHub OIDC — no long-lived credentials anywhere in the pipeline
  • All infrastructure in Terraform, removable with a single terraform destroy
  • Ships to AWS Lambda as a container image via the Lambda Web Adapter, exposed through a public Function URL
Keyless GitHub OIDC — no long-lived credentials anywhere
Gated Trivy scan, then manual approval before production
Reversible all infrastructure removable with one terraform destroy
The CICDAgent pipeline. CI on pull requests runs ruff and pytest in parallel, then builds the image and scans it with Trivy, and never deploys. CD on push to main lints, tests, builds and pushes a SHA-tagged image to ECR, deploys to staging, smoke tests, waits for manual approval, deploys to production, smoke tests, then notifies Slack. Any job failing posts a separate Slack alert.
Generated from the actual workflow files in the repo, not sketched. The amber gate is a GitHub Environment with a required reviewer — production cannot ship without a human. The one image built at the start is the same digest promoted to both environments.

Case study 04 — Vision-language research

From detection to a deployed vision-language system

Built the model, then built the benchmark that proves it.

The through-line of an industry-embedded PhD, jointly supervised by RMIT University and Carsales.com Ltd and awarded in May 2026. The problem stayed constant — assess vehicle damage from an image, accurately enough to act on — while the method progressed from attention-based classification, through text-guided grounding, to an end-to-end vision-language model producing structured output. The last step went into production; a separate published benchmark exists to keep its claims honest.

01 · Detection

CarDNet

Can attention tell real damage from a reflection?

A CNN-attention car damage classification network proposing a Convolutional Attention Module: parallel channel and spatial attention sub-modules inserted after each residual block in a ResNet50 backbone. Channel attention decides what to focus on, spatial attention decides where — together they separate real damage from artefacts like reflections and shadows.

  • Dataset — a curated, annotated, balanced set combining private Carsales data with the public CarDD dataset, augmented to 5,000+ images per class across six categories: dent, scratch, glass shatter, tyre flat, lamp broken, no damage
  • Benchmarking — ResNet50 + CAM against VGG16 and DenseNet121 backbones, and against eight state-of-the-art attention mechanisms (SENet, SRM, Gate, GCNet, CCNet, BAM, Coordinate, SPNet), with ablation studies isolating the channel and spatial contributions

02 · Grounding

GroundingCarDD

Can a description locate the damage it describes?

Text-guided multimodal phrase grounding for car damage detection, fusing visual and textual signals to localise damage precisely from natural-language descriptions, and outperforming baselines on mAP and recall. Published in IEEE Access, vol. 12, pp. 179464–179477, 27 November 2024.

03 · Production

CarDVLM

Can it produce something a business can act on?

The PhD's flagship contribution and the system that shipped. An end-to-end vision-language model combining object detection with structured reasoning to output damage type, location and severity — evaluated on both structured accuracy and semantic quality, and reported as achieving state-of-the-art performance. It was scaled into production on AWS with Metaflow inference workflows.

20→6
minutes per automated assessment in production, after deployment
1.4×
operational throughput versus the prior workflow

04 · Evaluation

CarDamageEval

How would anyone check a claim like that?

A benchmark framework for evaluating car damage assessment with vision-language models, using a dual-layer evaluation approach that measures structured accuracy and semantic quality together. It proposes a hybrid CarDD_Score metric and validates it against a curated annotated dataset with baseline experiments. Published in the proceedings of AusDM'25, the 23rd Australasian Data Science and Machine Learning Conference.

This is the same instinct as the agentic track, arrived at from the other direction: the model and the thing that grades the model are two halves of one piece of work.

Tech stack

What I actually work in

Current tooling only. Every item below appears somewhere in the work above — nothing here is listed on the strength of having read about it.

Agentic & LLM engineering

  • LangChain
  • LangGraph
  • Claude Agent SDK
  • Model Context Protocol (MCP)
  • Multi-agent orchestration
  • RAG & agentic RAG
  • LLM-as-judge evaluation
  • Pydantic
  • FastAPI

AI / ML

  • Computer vision
  • Multimodal AI
  • LLMs & VLMs
  • LLM fine-tuning
  • PyTorch
  • TensorFlow
  • Scikit-learn
  • Data science

Big data & geospatial

  • PySpark
  • Apache Sedona
  • Parquet
  • Distributed geospatial processing
  • Origin–destination modelling

Cloud & MLOps

  • AWS — EC2, EMR, Athena
  • Amazon SageMaker
  • Amazon Bedrock
  • AWS Lambda & ECR
  • Docker
  • GitHub Actions & CI/CD
  • Metaflow
  • MLflow
  • DVC

Research practice

  • Benchmark dataset curation
  • Evaluation framework design
  • Ablation studies
  • Systematic literature review
  • Explainable AI (GradCAM)
  • Peer-reviewed publication
  • Research supervision

Programming

  • Python
  • TypeScript
  • SQL
  • Pandas
  • Git
  • pytest

Certifications & credentialed projects

Certified, and built

Each credential is paired with the open-source project that demonstrates it in practice. Where that project is one of the case studies above, the link goes there rather than repeating it.

Udacity Nanodegree

Agentic AI Engineer with LangChain & LangGraph

LangGraph agent orchestration, retrieval-augmented generation, human-in-the-loop workflows, multi-agent architecture and routing.

Demonstrated in → UDA-Hub

Udacity Nanodegree

Agentic AI

Agent workflows and orchestration patterns, tool calling, state and memory management, multi-agent routing, agentic RAG with evaluation loops.

Demonstrated in → AgentProof, case study 01

Udacity Nanodegree

Machine Learning DevOps Engineer

Production ML pipelines, automated retraining, drift monitoring, CI/CD, and API deployment with FastAPI, MLflow and GitHub Actions.

Demonstrated in → CICDAgent, case study 03

Udacity Nanodegree

Data Scientist

CRISP-DM, ML pipelines with NLP, recommendation systems, and software engineering practice for data science.

Demonstrated in → PromptProof, case study 01

Verify — Agentic AI Verify — ML DevOps & Data Scientist All certifications

The proof projects, in brief

UDA-Hub

  • A Universal Decision Agent for customer support: a LangGraph multi-agent system that reads, reasons, routes and resolves tickets end to end. Supervisor pattern across six agents — classifier, supervisor, knowledge, resolver, escalation, memory — with the StateGraph built from scratch and no prebuilt agent constructors. A Pydantic TicketClassification schema drives deterministic, fully logged routing; RAG sits behind an escalation gate so low retrieval confidence hands off to a human rather than answering ungrounded; and memory is three-tier — typed run state, thread checkpointing, and long-term cross-session memory in SQLAlchemy. Modelled on a first client account, "CultPass," and tested against nine cases covering both resolution and escalation. Repo ↗

Other coursework

  • EcoHome Energy Advisor — an energy optimisation agent combining weather-forecast integration to predict solar generation, time-of-day dynamic pricing, historical usage analysis, and a RAG pipeline for energy-saving tips across EVs, HVAC, appliances and solar. Repo ↗
  • Document Assistant — a LangChain and LangGraph multi-agent document processor routing between Q&A, summarisation and calculation agents over financial and healthcare documents, with Pydantic schemas for intent classification and answer structure. Repo ↗
  • LLM exercises — a learning repository of small, focused exercises. Listed for completeness rather than as original work: it is inspired by, and in places directly adapted from, Ed Donner's MIT-licensed llm_engineering course materials, with the original licence notices retained. Repo ↗

Research & publications

The peer-reviewed record

The credibility layer under the work above. Five first-authored publications during the PhD, including three Scimago Q1 journal papers, plus collaborative work in biomedical imaging.

500+Citations
12h-index
14i10-index
2025

CarDamageEval: Benchmark Evaluation of Car Damage Assessment Using Vision Language Models

Hasan, M.J., Jahani, H., Boo, Y.L., Ong, K.L.

Proceedings of AusDM'25 — 23rd Australasian Data Science and Machine Learning Conference

Project page

2025

Vehicle Damage Detection Using Artificial Intelligence: A Systematic Literature Review

Hasan, M.J., Nguyen, K.C., Jahani, H., Boo, Y.L., Ong, K.L.

WIREs Data Mining and Knowledge Discovery, 15: e70027 Scimago Q1 · IF 11.7

10.1002/widm.70027

2025

Enhancing Brain Tumor Classification with a Novel Attention Based Explainable Deep Learning Framework

Hasan, M.J., Hasan, M., Akter, S., Mahi, A.B.S., Uddin, M.P.

Biomedical Signal Processing and Control, Vol. 112 Scimago Q1 · IF 4.9

SSPANet — combining Z-pool channel attention, strip pooling for long-range spatial context, and style pooling for fine-grained texture awareness, integrated with VGG16 and ResNet50 backbones and made explainable via GradCAM, GradCAM++ and EigenGradCAM. ResNet50 + SSPANet reports 97% accuracy, precision, recall and F1, with 95% Cohen's Kappa and Matthews Correlation Coefficient, on the Figshare Brain Tumor Dataset (3,064 T1-weighted contrast-enhanced MRI images, 233 patients, three tumour classes).

10.1016/j.bspc.2025.108636 Code Project page

2024

GroundingCarDD: Text-Guided Multimodal Phrase Grounding for Car Damage Detection

Hasan, M.J., Nalwan, A., Ong, K.L., Jahani, H., Boo, Y.L., Nguyen, K.C.

IEEE Access, vol. 12, pp. 179464–179477 Scimago Q1

10.1109/ACCESS.2024.3506563 Project page

Teaching & supervision

Four teaching and supervisory roles at RMIT

Alongside the research: supervising applied aviation projects, and teaching the analytics and infrastructure courses that feed into them.

Supervision

Commencing 2026

Postgraduate Research Co-Supervisor

Aviation Master's Program · RMIT University

Co-supervising a postgraduate research project applying AI methods to a real-world aviation challenge, within a joint supervisory team.

Supervision

5 groups · ~20 students

Group Supervisor, Aviation Industry Project

Course 2650 · RMIT University

Supervising five student research groups, around twenty students, through applied research projects addressing real-world aviation industry challenges.

Teaching

ISYS3449

Teaching Assistant, Advanced Business Analytics

RMIT University

Delivered tutorials and workshops on data preparation, visualisation and machine learning methods using Python and AI Studio, guiding students through model development, evaluation and advanced analytics topics.

Teaching

INTE2043

Teaching Assistant, Business IT Infrastructure

RMIT University

Facilitated labs on IT infrastructure and cloud systems — Linux administration, networking and server deployment — and introduced advanced topics including virtualisation, containers, IoT and APIs.

Education

Sep 2022 – May 2026

PhD in Business Information Systems

RMIT University · awarded May 2026

An industry-embedded programme jointly supervised by RMIT and Carsales.com Ltd, advancing multimodal AI for intelligent vehicle assessment.

Grants & funding

PRJ00000694

Industry Grant, RMIT–Carsales

Supported the development of GroundingCarDD and CarDVLM.

Jan 2025 – Dec 2026

RACE AWS Merit Allocation Scheme

Four consecutive rounds

AWS cloud computing credits supporting large-scale data preparation, model training and multi-agent system development.

Recognition

2025

PhD HDR Certificate of Excellence

RMIT University

Elected role

HDR Candidate Representative

College of Business and Law, RMIT University

Writing

The build-in-public trail

Eight posts written as the agentic work shipped, in order. Each one is paired with the code it describes, so the argument and the implementation can be read against each other.

Other writing

All posts on Medium

Contact

Open to applied AI research and agentic engineering roles

Melbourne, Australia. Happy to talk about agentic systems, multi-agent workflows, vision-language models, or geospatial analytics at scale.