Junction — Your AI-Powered Automotive Ownership Companion

Inspiration

Owning a car should not feel like navigating five different platforms just to make one decision.

When something goes wrong with your vehicle, you search forums, compare repair estimates, look for nearby mechanics, and try to determine which advice to trust. When you want to sell your car, you research market prices, create listings, and search for potential buyers. When buying a car, you repeat the process in reverse.

The information exists, but it is scattered, disconnected, and difficult to act on.

We asked ourselves a simple question:

What if your car had one intelligent companion that could help you through every stage of ownership?

That idea became Junction.

Built at HackTX 2026, Junction brings vehicle buying, selling, valuation, and repair assistance into one AI-powered platform, with a focus on Toyota vehicles.

What It Does

Junction is an automotive ownership platform powered by a coordinated system of specialized AI agents.

Instead of relying on one general-purpose chatbot to handle everything, Junction separates automotive tasks into dedicated agents that use structured tools, database records, and specialized workflows.

Vehicle Buying

Junction helps users explore available vehicles, search published listings, manage their buying preferences, and identify vehicles that match their needs.

Vehicle Selling

Owners can retrieve their vehicle information, prepare private selling requests, receive available pricing guidance, and discover potential buyers through published buyer-interest posts.

Vehicle Valuation

Junction analyzes comparable published vehicle asking prices to produce evidence-based market estimates when sufficient data is available. It distinguishes observed asking prices from completed sale prices and keeps new-vehicle MSRP separate from used-vehicle valuation.

Repair Assistance

When a vehicle develops a problem, Junction helps owners record repair issues, save diagnostic information, search similar repair experiences, explore nearby mechanics, and track how problems were resolved.

Community Marketplace

Junction also uses published posts to connect vehicle listings, buyer interests, and shared ownership experiences, creating a growing source of useful automotive knowledge.

Together, these capabilities aim to support the complete ownership journey: buy, own, maintain, and sell.

How We Built It

We designed Junction around a multi-agent architecture using Google Agent Development Kit (ADK) and Gemini.

A central Coordinator is responsible for interpreting user requests and directing tasks to specialized agents.

Our architecture includes:

Coordinator Agent: Routes requests and orchestrates specialist workflows.
Buyer Agent: Handles vehicle discovery and buying requests.
Seller Agent: Manages selling workflows and public buyer-interest matching.
Valuation Agent: Evaluates comparable listing evidence.
Repair Agent: Handles repair records, diagnostic information, and mechanic discovery.
Post Agent: Supports the platform's published-post workflows.

Each specialist connects to deterministic Python service functions rather than depending entirely on AI-generated answers.

For our backend, we used Python, Django, and Django REST Framework to implement APIs, authentication, business logic, and database operations.

We use PostgreSQL to store vehicle records, user-specific buying and selling requests, repair issues, and published posts.

The frontend is built with React and JavaScript, providing the interface through which users interact with the platform.

We also incorporated external data integrations, including Google Places API for nearby mechanic discovery, with a service architecture designed to keep external results separate from database-backed information.

A major architectural decision was to separate AI reasoning from database authority. Gemini helps interpret requests and explain results, while Django services enforce ownership, validate inputs, retrieve records, and persist authorized changes.

Challenges We Faced

1. Coordinating multiple AI agents

Building individual agents was only part of the problem. We needed clear responsibilities, consistent tool interfaces, and a Coordinator capable of routing requests without duplicating business logic.

We addressed this by separating specialist workflows and using Google ADK for agent construction and tool integration.

2. Connecting AI to real database records

We wanted Junction to do more than generate convincing automotive advice.

The system needed to work with actual vehicle records, buying requests, selling requests, and repair histories.

We implemented Django service layers that interact with database models and enforce authentication and ownership restrictions. Integrating those structured results through the full Coordinator and frontend workflow became an important engineering challenge.

3. Making estimates trustworthy

Automotive pricing data can be incomplete or misleading.

We designed our valuation logic to distinguish asking prices from verified sales, require sufficient comparable evidence, and return an insufficient-data result when a defensible estimate cannot be produced.

We applied similar safeguards to repair-cost estimation rather than inventing unsupported numerical figures.

4. Protecting private user information

A public marketplace listing and a private user record are not the same thing.

We separated private buying, selling, and repair records from approved public posts, and designed services to enforce ownership and publication restrictions.

5. Building under hackathon time constraints

We worked in small, testable increments, developing individual service functions, automated tests, and documentation before integrating them into ADK agents.

This allowed us to build substantial backend functionality while keeping changes understandable and easier to debug.

What We Learned

Junction taught us that building a useful AI product requires much more than connecting an LLM to an interface.

We gained practical experience with:

Designing multi-agent systems with Google ADK.
Creating deterministic tools for AI agents.
Integrating Django ORM models with AI workflows.
Building authenticated, user-scoped backend services.
Handling structured data and JSON serialization.
Designing safe fallbacks when external evidence is insufficient.
Writing automated tests for agent tools and database operations.
Collaborating across frontend, backend, and AI integration responsibilities.

Our biggest lesson was that AI should help users make decisions, but verified application data and backend rules should determine what the system can actually do.

What's Next

Our vision is for Junction to become a complete automotive ownership companion.

The next steps include completing end-to-end integration across the frontend and Coordinator, expanding trustworthy vehicle valuation data, and introducing secure buyer–seller messaging.

Longer term, we envision a community where every repair experience, vehicle listing, and ownership insight can help another driver make a better decision.

*Junction Someone's been through this before *