Argus

Most smart glasses are expensive and require you to buy an entirely new pair of glasses. ARGUS turns glasses you already own into AI glasses

Comment

Inspiration

Smart glasses are powerful, but most of them are expensive and require users to buy a completely new pair of glasses.

We wanted to explore a different idea.

What if you could turn the glasses you already own into AI glasses?

That idea became Argus, a small attachable AI module designed to give normal glasses vision, voice, translation, and AI assistance without replacing the glasses themselves.

Our goal was to make smart glasses more accessible, modular, and affordable.

What it does

Argus is an AI assistant that can attach to a normal pair of glasses.

A user can speak naturally to Argus and receive an AI generated voice response.

Argus can also use its camera when a question requires visual information.

For example, a user can ask:

"What am I looking at?"

Argus captures an image using the camera, sends it to the backend, analyzes the image together with the user's question, and responds with an answer.

Argus can also translate text that the user sees.

The system supports:

Voice input

AI question answering

Camera based visual understanding

Text and object recognition

Translation

AI voice responses

A web interface that shows transcripts, captured images, responses, and system status

The important part is that Argus does not need to use the camera for every request. The system can decide when visual information is needed and use the camera only when necessary.

How we built it

Argus is split into a hardware system and a cloud backend.

The hardware uses an ESP32 CAM mounted onto the glasses. The ESP32 connects to WiFi and communicates with our backend.

When the user speaks, audio is sent to our Python backend.

We use Deepgram for speech to text. Deepgram converts the user's voice into text.

That text is then sent to Backboard, which handles the AI reasoning and conversation.

If the question needs visual information, the system requests an image from the ESP32 camera and sends the image together with the user's question for analysis.

Once the AI generates an answer, we use ElevenLabs to convert the answer from text into natural sounding speech.

The basic pipeline is:

Voice input → Deepgram → AI reasoning → ElevenLabs → Audio response

For visual questions, the pipeline becomes:

Voice input → Deepgram → Camera capture → AI reasoning with image → ElevenLabs → Audio response

Our backend is built with Python and FastAPI and deployed using Render.

We also built a web interface that connects to the backend and displays what Argus is doing in real time, including the user's transcript, camera image, AI response, and current system state.

Challenges we ran into

One of our biggest challenges was connecting hardware and cloud software into one reliable system.

The ESP32 camera, Python backend, AI services, audio system, and web interface all had to communicate correctly.

Audio was another major challenge.

We experimented with different ways of sending the AI response back to the user, including Bluetooth audio and direct audio playback. We had to think carefully about latency, audio formats, hardware limitations, and reliability.

Camera communication also caused problems. The backend needed to know when the camera was available and when a request actually required an image.

Another challenge was fitting everything into something that could realistically be worn on glasses. Hardware that works on a desk is much easier than hardware that has to be small, light, and attached to a person's head.

We also had a limited amount of time, so we had to constantly decide which features were important for the core experience and which features could wait.

Accomplishments that we're proud of

We are proud that Argus became more than just an idea or UI prototype.

We built a working system where physical hardware can communicate with a cloud AI backend.

The camera can capture what the user is seeing.

The system can understand spoken questions.

The AI can reason using both text and images.

The response can then be converted back into speech.

We are also proud of the modular idea behind Argus.

Instead of designing another expensive pair of smart glasses, we designed Argus around the idea that the intelligence should be attachable.

That means the same system could potentially work with many different glasses instead of forcing the user to replace them.

What we learned

We learned that building an AI hardware product is very different from building only software.

Every part of the system affects the others.

Network speed affects response time.

Audio formats affect hardware playback.

Camera resolution affects upload speed.

Hardware size affects what can actually be worn.

We also learned that a good AI product does not need every sensor running all the time.

Argus becomes much more useful when it can decide whether a question needs only language reasoning or whether it needs to use the camera.

Most importantly, we learned how to connect embedded hardware, speech recognition, multimodal AI, text to speech, cloud APIs, and a frontend into one complete system.

What's next for Argus

Our next goal is to make Argus smaller, lighter, and more independent from external devices.

We want to improve the wearable enclosure so the module can attach securely to different styles of glasses.

We also want to improve the optical display so information such as translations, navigation, and short AI responses can appear directly in the user's field of view.

Future versions could include better onboard audio, improved battery life, lower latency, and more efficient camera processing.

We also want Argus to become more proactive.

Instead of only answering questions, future versions could understand context and help the user while they are moving through the real world.

Our long term goal is simple:

Turn the glasses people already wear into useful AI glasses.

Built With

Share this project:

Updates