• 

  What is Acumen?

• 

  Acumen Architechture

• 

  Acumen's Future

Inspiration:

When brainstorming ideas for the Work & Productivity track, we wanted to build something that we could use in our own day-to-day. We came across research detailing how fractured modern screen attention spans have become, and it mirrored our experiences in college and work. Managing productivity often turns into a second job. We set out to fix that by creating Acumen: an ambient desktop companion that meets you where you work and actively combats digital burnout.

What it does:

Acumen is an ambient desktop study and productivity assistant that keeps users locked into deep work without adding interface friction. Key capabilities include:

- Frictionless Session Setup:

Launch a study or work session with one click, or collapse the interface into a compact, always-on-top floating widget.

- Proactive AI Companion:

An integrated assistant that monitors focus, checks in during idle or distracted periods, and offers guidance or stress-relief interventions.

- Voice & Ambient Interactions:

Hands-free communication powered by dynamic voice synthesis, reducing the need to task-switch.

- Automated Analytics:

Summarizes session performance, distraction triggers, and productivity metrics in real time.

How we built it:

Acumen runs on a native desktop wrapper built with React and Electron, using a multi-branch data orchestration pipeline:

- Gemini API:

Serves as the core intelligence engine for context synthesis, conversation, and automated session summaries.

- ElevenLabs:

Delivers low-latency, natural voice audio for conversational check-ins.

- Presage:

Analyzes user state and physiological focus cues to detect fatigue and distraction.

- Backboard:

Manages persistent state, middleware routing, and conversation memory across sessions.

Challenges we ran into:

- Multi-Branch Event Orchestration:

Handling parallel execution paths in our intelligence pipeline proved challenging. When an idle trigger fired alongside an active voice command, our Gemini orchestration layer risked processing conflicting states simultaneously. We had to design an asynchronous queue and debouncing mechanism to prevent redundant API calls and ensure that workflow metrics, live companion responses, and Backboard state updates synchronized deterministically.

- Continuous Physiological Stream Ingestion:

Ingesting continuous metric feeds from Presage without degrading desktop rendering performance required careful optimization. Running continuous computer-vision/physiological evaluations alongside a responsive Electron UI led to initial CPU spikes. We had to offload heavy stream processing, rate-limit metric polling, and decouple the evaluation loop from the React render cycle.

- Electron Overlay & OS-Level Event Handling:

Building a true always-on-top, non-intrusive widget required navigating platform-specific window manager quirks. Preventing the Electron window from stealing OS focus when switching between full-screen IDEs or browsers—while still allowing mouse click-through in minimized mode and responsive drag behavior—required low-level window flag configuration across native desktop environments.

Accomplishments that we're proud of:

• The successful integration of Gemini, ElevenLabs, Presage, and Backboard into an all-in-one desktop application.
• The many functionalities we were able to get out of just Gemini as a companion which includes but not limited to: real-time biometric scanning, document and presentation creation, google calendar updating.
• The breadth of capabilities while maintaining the compact, concise, and customizable design.

What we learned:

- Deterministic State Orchestration in Multi-Agent Systems:

Managing concurrent user inputs, idle triggers, and ambient sensor feeds taught us how to design robust queueing, state-locking, and debouncing architectures. We learned how to prevent race conditions when multiple micro-services (Gemini reasoning, voice synthesis, and Backboard updates) execute simultaneously.

- Optimizing Continuous Metric Ingestion:

Handling real-time data streams from Presage without blowing up CPU usage taught us the importance of decoupling data processing loops from UI re-renders. We gained hands-on experience with client-side throttling, offscreen buffering, and state batching in React.

- Context Window Strategy & Middleware Memory:

Working with Backboard and the Gemini API gave us practical insights into context hygiene. We learned how to design tiered memory structures—keeping transient session signals lightweight while persisting essential behavioral context, avoiding latency spikes and prompt bloat.

What's next for Acumen:

- Phase 1: Desktop Ergonomics & Polish

With our persistent, "always-on-top" display mode already implemented, the next immediate priority is perfecting workspace feel. This includes adding native snap-to-edge screen docking, dynamic window resizing with responsive compact breakpoints, and deeper local metric collection so users can review detailed focus curves immediately after every session.

- Phase 2: Cloud Sync, Analytics & Automated Executables

To provide continuous value over time, we will integrate a Supabase backend to persist session analytics, distraction triggers, and focus milestones across devices. Leveraging this foundation, we will empower the assistant to trigger in-application executables—enabling users to launch custom project environments, automate workspace setup, and control background distraction blockers purely via natural conversational cues.

- Phase 3: Multiplayer Accountability & Collaborative Sessions

To bring accountability to remote work and study, we will roll out a hosted "Join Session" server architecture. Users will be able to join collaborative virtual study rooms with peers, sharing real-time aggregate focus stats and milestone completions while keeping personal telemetry private.

Built With

• backboard
• elevenlabs
• google-gemini
• javascript
• node.js
• presage
• react