HAULR 🚛 — The Open Road, Planned to the Minute
What I Built
I built HAULR, an AI-powered HOS Trip Planner and ELD Log Generator for truck drivers and dispatchers.
Planning a long-haul trip is much more complicated than simply finding the shortest route. A driver has to account for driving limits, mandatory breaks, rest periods, fuel stops, duty windows, and cycle limits — all while making sure the final schedule remains compliant.
HAULR brings all of that together into one application.
A driver enters their current location, pickup location, drop-off location, and current cycle hours. HAULR then generates:
- 🗺️ An interactive route with planned stops
- ⏱️ HOS-compliant driving and rest schedules
- ⛽ Fuel and break stops
- 📋 Automatically generated daily ELD logs
- 📄 Exportable PDF logs
- 🤖 An AI Copilot called Rig
- 📚 RAG-powered answers to FMCSA/HOS questions
- 🧠 Agentic controls that allow the AI to interact with the trip planner
The most important design decision was keeping the HOS calculations deterministic. The AI is used for reasoning, retrieval, natural-language interaction, and tool use — while the actual compliance calculations are handled by a dedicated Python HOS engine.
This makes HAULR much more than a chatbot for truck drivers.
It's an AI interface on top of a real trip-planning system.
Code
The complete source code is available here:
https://github.com/LakSHyaMudgal1/CargoTrip
HAULR is built as a full-stack application with a React/TypeScript frontend, Django/DRF backend, agentic AI layer, PostgreSQL/pgvector storage, and a deterministic HOS simulation engine.
How I Built It
The frontend is built with React, TypeScript and Vite, while the backend uses Django and Django REST Framework.
The AI layer uses LangChain and LangGraph to create an agent capable of:
- Understanding a driver's request
- Retrieving relevant HOS/FMCSA information
- Calling application tools
- Maintaining conversation state
- Explaining compliance decisions
- Interacting with the trip-planning workflow
I experimented with both Ollama and Groq during development to work with fast, locally runnable/open-weight models in addition to hosted models.
The architecture separates AI reasoning from the critical compliance engine.
Deterministic HOS Engine
The HOS engine models:
- 11-hour driving limit
- 14-hour duty window
- 30-minute break requirement
- 70-hour / 8-day cycle
- Rest periods
- Fuel and operational stops
The engine produces the driver's duty-status timeline, which is then used to generate the ELD logs.
RAG
Rig can answer HOS questions using retrieval over the FMCSA handbook rather than relying only on the model's internal knowledge.
The project uses PostgreSQL with pgvector for semantic retrieval and persistent agent state.
Agentic UI
One of my favorite parts of the project is that Rig isn't limited to answering questions.
The agent can interact with the application through tools, allowing natural-language commands to become actions inside the trip planner.
For example, instead of manually navigating through multiple controls, the user can interact with the system conversationally.
Why Does Open Innovation Matter?
For HAULR, open innovation is important because the application is not just an LLM wrapper.
It combines:
- Open-source agent frameworks
- Local model inference through Ollama
- Open-weight models
- Retrieval systems
- Vector search
- Deterministic domain-specific algorithms
- Tool calling
- Persistent agent state
- A complete full-stack application
Using open tooling means I can experiment with different models and architectures without rebuilding the entire application around one proprietary provider.
For example, Ollama made it possible to experiment with models locally, while Groq provided a fast inference path when speed mattered.
This flexibility is especially valuable for an application like HAULR, where AI should be one component of a larger reliable system rather than the entire system.
The project demonstrates the idea I care about most:
AI should augment reliable software systems, not replace them.
The HOS engine handles the rules.
The retrieval system handles the documentation.
The agent handles natural-language reasoning and tool orchestration.
And the user gets one unified experience.
My Agent Session
I built HAULR using an agentic development workflow with DevRelay.
The agent sessions show how the application evolved from requirements and architecture into the final implementation, including the reasoning behind different parts of the system.
Prize Categories
Featured Categories
-
Gemma — Best Use of Gemma
- [Include this only if the submitted version demonstrably uses Gemma through Ollama/Groq.]
Partner Categories
-
Entire — Best Use of Entire
- Sharing the agent sessions behind the project and documenting the development process.
[Add other categories only where the implementation actually satisfies the partner's requirements.]
Final Thoughts
HAULR started with a simple question:
What if planning a truck trip could be as simple as talking to an assistant?
The result became a combination of deterministic HOS simulation, route planning, ELD generation, RAG, and an agentic AI copilot.
Instead of asking AI to simply tell a driver what to do, I wanted to build a system where AI could actually work with the application.
🚛 The open road, planned to the minute.
Top comments (0)