Plug

Ask for anything nearby in your own words. Open-weight AI on your device understands it, and real people answer.

Comment

PLUG: Local help, in your own words.

Inspiration

Your kitchen sink is leaking. You need someone who can fix it today, but you only have $90. Or maybe you're heading to a nearby café and want to know what's happening there right now.

These should be simple questions to answer. Instead, people spend time searching through listings, making calls, comparing prices, and hoping the information they find is still accurate.

Meanwhile, someone nearby might have exactly the skill they need.

We built PLUG to make connecting with your local community as simple as asking a question.

No complicated filters. No guessing which category to search. Just describe what you need in your own words.

What it does

PLUG is an AI-powered iPhone app that helps people find local services and explore what's happening around them.

A user can type:

"My kitchen sink is leaking. I need someone today, under $90."

PLUG uses AI to understand the request and extract structured information, including:

  • Skill: Plumbing
  • Budget: $90
  • Time: Today
  • Location: The user's specified area

This creates a structured request that can be used to find relevant service providers.

PLUG also introduces a second way to explore your community: asking what's happening at a nearby place.

Instead of relying only on static listings, users can ask about local activity and receive a readable summary of community observations.

For the hackathon demonstration, provider information and neighborhood reports are simulated. PLUG explicitly labels this information as simulated, so users aren't misled into believing the app has confirmed real-time local activity or provider availability.

The goal is to turn everyday questions into useful local information without sacrificing transparency.

How we built it

We built PLUG using:

  • SwiftUI: Native iPhone application
  • Java and Spring Boot: Backend services and request processing
  • Next.js: Website and administration interface
  • Qwen 3: Open-weight language model for natural-language understanding and simulated neighborhood reports
  • Ollama: Local model inference, running directly on a laptop

The AI runs locally

One of our biggest technical decisions was running Qwen 3 locally through Ollama.

PLUG does not need a cloud AI provider or an external API key for model inference.

When someone submits a natural-language request, Qwen 3 interprets what they're asking and extracts the relevant service, budget, timing, and location information.

The model also generates simulated neighborhood observations for our local activity demonstration.

We built safeguards around the model

We didn't want to assume that every AI-generated response would be correct or safe.

Instead, we designed the system with multiple layers:

  1. Safety rules run before model processing to check incoming requests.
  2. Qwen 3 interprets the request and produces structured information.
  3. The backend validates the model's output before accepting it.
  4. The app distinguishes simulated information from verified information so users understand what they're seeing.

The language model handles interpretation, but the backend remains responsible for enforcing application rules.

We also established shared API contracts across the iPhone app, backend, and web interface, and tested the integration on a physical iPhone.

Challenges we ran into

Running AI without cloud infrastructure

We wanted PLUG's language understanding to work without relying on paid AI APIs.

Running Qwen 3 locally meant working within the hardware and performance constraints of a laptop while keeping the model useful for structured request interpretation.

Making AI outputs reliable

Language models don't always return perfectly structured information.

A request may omit a location, describe a budget ambiguously, or combine multiple needs in one sentence.

We had to separate the AI's responsibility for interpreting language from the backend's responsibility for validating results and enforcing rules.

Building trust before having a live community

A local marketplace depends on real people, real availability, and fresh information.

We don't yet have a live network of providers or neighborhood contributors. Rather than inventing activity and presenting it as real, we created simulated provider and neighborhood data for the demo and made that limitation visible in the interface.

Integrating multiple technologies

Building a native iPhone app, Java backend, web interface, and local AI inference system required coordination across different technologies.

Shared contracts, test fixtures, and physical-device testing helped us keep the components working together.

Accomplishments that we're proud of

1. Running a real open-weight AI model locally.

PLUG uses Qwen 3 through Ollama for actual request interpretation. This isn't a hardcoded keyword search or a mock AI response.

2. Turning everyday language into structured requests.

Users can describe their needs naturally, including constraints like budget, timing, and location, without manually completing multiple search filters.

3. Building validation around AI-generated results.

Our safety and backend validation layers ensure that model output isn't automatically trusted simply because it looks plausible.

4. Connecting a native iPhone experience to our backend.

We built and tested the application on a physical iPhone, connecting the user-facing experience to the underlying services.

5. Making simulation transparent.

Our prototype demonstrates what neighborhood intelligence could look like while clearly identifying simulated providers and community reports.

We're proud that PLUG is a working technical foundation, not just a pitch or collection of screens.

What we learned

We learned that building useful AI products isn't just about getting a language model to generate an answer.

The harder problem is deciding what the model should control, what the software must verify, and what the user can actually trust.

We learned how to integrate an open-weight model into a larger application, turn unstructured language into structured data, and validate model-generated outputs before using them.

We also learned that local information is fundamentally different from general knowledge. A model can understand a question about a nearby business, but it cannot know what's happening there right now without fresh observations.

That distinction shaped how we designed PLUG and why we clearly label simulated information.

Most importantly, we learned that technology should make community connections easier without pretending to know more than it does.

What's next for PLUG

Our next step is taking PLUG from a functional prototype to a real neighborhood pilot.

We want to:

  1. Onboard real local providers who can list their skills, pricing, and availability.
  2. Enable real provider responses and reservations so users can move from requesting help to confirming a service.
  3. Introduce verified neighborhood contributions that allow people to share fresh observations about local places.
  4. Expand privacy-conscious AI capabilities while preserving our open-weight model approach.
  5. Test in one neighborhood and measure response rates, successful matches, and user trust.

The $1,500 grand prize would help cover hosting, messaging, developer access, and initial pilot expenses.

Our long-term vision is straightforward:

When you need something nearby, you shouldn't have to know where to search. You should just be able to ask.

That's what we're building with PLUG.

Built With

Share this project:

Updates

Submission history