DEV Community: Lakshya Mudgal

[Boost]

Lakshya Mudgal — Sun, 11 Oct 2026 06:42:11 +0000

Lakshya Mudgal

Oct 11

HAULR: An Open-Source AI Copilot for Smarter Truck Trip Planning & ELD Logs 🚛

#devchallenge #hf26challenge #ai #python

2 min read

HAULR: An Open-Source AI Copilot for Smarter Truck Trip Planning & ELD Logs 🚛

Lakshya Mudgal — Sun, 11 Oct 2026 05:45:00 +0000

HAULR: AI-Powered HOS Trip Planner & ELD Log Generator 🚛

This is my submission for the Hacktoberfest Open-Source AI Challenge Week 1: Touch Grass.

What I Built

I built HAULR, an AI-powered trip planning assistant designed to help truck drivers spend less time dealing with complicated logistics and more time focusing on the road.

Truck drivers often have to manage routes, Hours of Service (HOS) regulations, rest breaks, and Electronic Logging Device (ELD) records. Planning a trip while staying compliant can be time-consuming and stressful.

HAULR aims to simplify this process by helping drivers plan trips, understand driving and rest schedules, and generate structured ELD logs.

The goal is to make logistics easier through AI while encouraging a healthier balance between screen time and real-world activities. Instead of constantly switching between tools and manually calculating schedules, drivers can use a more streamlined workflow to plan their journeys.

Code

🚀 Github: https://github.com/LakSHyaMudgal1/CargoTrip

Explore the code, understand the implementation, and feel free to contribute ideas or improvements!

How I Built It

I built HAULR around a web-based architecture with a focus on practical AI integration and useful automation.

Backend: Python and Django for application logic and backend services.
AI integration: An AI-powered workflow to assist with trip planning and natural-language interactions.
Trip planning: A workflow for organizing routes, driving periods, and rest breaks.
ELD logs: Structured generation of trip and driving-log information.
Open-source development: An architecture designed to make the project easier to inspect, extend, and improve.

The core idea was to apply AI to a real-world problem rather than build another chatbot that only answers general questions.

Note: The exact model, framework, and inference setup should be added here to reflect the open-weight model and tools actually used in the project.

Why Does Open Innovation Matter?

Open innovation makes projects like HAULR possible because developers can learn from existing tools, inspect implementations, experiment with different models, and build on the work of the community.

Using open-source AI can provide greater flexibility in choosing models, adapting workflows, and understanding how the system operates. It also creates opportunities for contributors to improve reliability, add features, and tailor the solution to different requirements.

For a project involving logistics and regulatory constraints, transparency and the ability to validate the underlying logic are especially valuable. AI can assist with planning, but compliance-critical calculations should be checked against applicable regulations rather than blindly trusting generated responses.

This challenge was a great opportunity to explore how open-source AI can help solve a practical problem and encourage people to use technology more intentionally.

My Agent Session

I used DevRelay as part of my agentic development workflow.

Prize Categories

Open-Source AI
AI-powered real-world applications

Final Thoughts

Building HAULR reinforced my belief that AI is most useful when it solves a specific problem and fits naturally into people's everyday workflows.

I'd love to hear your feedback! What features would you add to make AI-powered trip planning more useful for truck drivers?

hacktoberfest #ai #opensource #python

HAULR 🚛: An AI-Powered HOS Trip Planner & ELD Log Generator for Truck Drivers

Lakshya Mudgal — Mon, 05 Oct 2026 05:59:30 +0000

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.