AlturaAI

AI that reads the web and gets things done

Comment

Inspiration

Everyday knowledge work is fragmented across tabs, emails, and repos. Small, repetitive micro-tasks—summarizing an article, drafting a reply, extracting a tracking number, or leaving a PR comment—add up to hours of lost focus and context switching.

I built AlturaAI because I wanted an assistant that lives where work happens (the browser) and turns passive web content into immediate, actionable outputs.

The personal trigger was repeatedly losing time switching contexts to extract a single fact—like a tracking ID, stock update, or code snippet—and then act on it. I wanted a pragmatic tool that saves small chunks of time every day.

What it does

AlturaAI is a browser extension plus a Node.js backend that uses built-in AI APIs to convert web pages, inbox items, and code into useful artifacts and actions.

Key capabilities

  • Page analysis & summarization: one-click summaries and highlights for the active tab or selected text.
  • Content composition: context-aware email drafts, Notion pages, and meeting notes generated from page content or selection.
  • GitHub integration: webhook-driven PR analysis and automated review suggestions that reviewers can accept or refine.
  • Inbox automation: scans Gmail (with consent) to detect shipment/order confirmations and surface tracking alerts.
  • Background automation: scheduled tasks (price monitoring, inbox scans) with Firebase notifications and secure OAuth-based actions.
  • Stock price alert system: allows users to set custom price thresholds for specific stocks. When a stock hits the target, AlturaAI instantly sends a browser or mobile notification showing the exact price and percentage change.
  • Momentum builder: analyzes short-term price movements and market patterns to suggest a user’s next step (buy, hold, or sell) using AI-driven momentum analysis.

How we built it

Architecture overview

  • Frontend (extension): content scripts and popup UI in src that capture page context, scrub and normalize DOM text, and present generated outputs.
  • Backend: Node.js + Express (in server-backend) handling OAuth flows (Google, GitHub, Notion), webhooks, JWT-based session auth, and cron jobs for scheduled scans.
  • AI layer: built-in LLMs (Google Gemini or equivalent) called from the backend for semantic extraction, summarization, composition, and code or market analysis. Prompts are structured into extract → classify → compose steps to minimize hallucination.
  • Real-time / async services: Firebase for push notifications, node-cron for background jobs, and secure token storage for refresh flows.
  • Stock integration: connected to live stock APIs (e.g., Alpha Vantage / Finnhub) to fetch current prices, calculate momentum, and trigger threshold-based alerts.

Implementation details

  • Page extraction: content scripts apply DOM heuristics and lightweight local summarization to reduce tokens before sending context to the LLM.
  • Prompting strategy: used prompt templates + chaining (extract → verify → compose) to improve accuracy and reduce cost.
  • OAuth & security: backend handles token exchanges, refresh, and consent prompts before any user-facing action.
  • Momentum calculation:

$$ M = \frac{P_t - P_{t-n}}{P_{t-n}} \times 100\% $$

where ( P_t ) is the current stock price and ( P_{t-n} ) is the price ( n ) intervals ago. Based on ( M ), the assistant classifies the stock action as Buy, Hold, or Sell.

Challenges we ran into

  • Noisy web data: arbitrary pages contain ads, boilerplate, and scripts. Clean inputs required DOM heuristics and filtering to avoid garbage in → garbage out.
  • Token and cost management: cascading summarization (local → short LLM → full composition) reduced costs but added implementation complexity.
  • OAuth friction & edge cases: multi-account, token refresh, and revocation handling required robust backend and careful UX.
  • Hallucination risk: LLMs occasionally fabricated facts (tracking numbers, stock values). Provenance and confirmation checks mitigated this.
  • Reliability: implemented exponential backoff, rate-limit handling, and graceful fallbacks to ensure consistent performance under load.

Accomplishments that we're proud of

  • End-to-end integration: a working Chrome extension that reads live pages, calls backend AI, and returns actionable outputs (summaries, PR comments, stock alerts).
  • Cross-service automation: OAuth integrations with Gmail, GitHub, and Notion enabled full workflows like creating Notion pages or automated PR reviews.
  • Financial awareness features: stock alerts and momentum insights gave users real-time decision support directly in the browser.
  • Prompt engineering breakthroughs: moving from single-shot prompts to extract/verify/compose chains improved precision and reduced hallucination rate.
  • User impact: early testers reported reduced manual tracking effort and better trading decision timing through alert notifications.

What we learned

  • Decomposition improves LLM reliability: breaking tasks into extract, validate, and compose steps is key for accuracy.
  • UX-security balance: how and where tokens are stored directly impacts trust—explicit consent and transparency matter.
  • Micro-automation scales: saving minutes per task compounds into measurable weekly time savings.
  • Financial data challenges: working with live APIs introduced edge cases (rate limits, delayed data) that shaped error handling.
  • Continuous optimization: tracking token usage and user flows helps manage LLM cost efficiency.

What's next for AlturaAI

  • On-device pre-filtering: move more pre-processing to the extension so sensitive data never leaves the browser unnecessarily.
  • Provenance & confidence: show confidence scores and source excerpts with each AI-generated artifact.
  • Expanded integrations: add Slack, Microsoft 365, and team dashboards for shared automations.
  • Adaptive prompts: implement A/B testing for prompt templates to improve accuracy for email drafts and PR comments.
  • Momentum evolution: integrate deeper trend analytics (EMA, RSI) to refine the Momentum Builder’s predictive accuracy.
  • Team & enterprise features: audit logs, policy controls, and role-based automation for collaborative environments.

Metrics (with LaTeX)

Time saved per automated task ( i ):

$$ \Delta t_i = t_{\text{manual},i} - t_{\text{auto},i} $$

Weekly aggregate time saved:

$$ T_{\text{saved,week}} = \sum_{i=1}^{N} (t_{\text{manual},i} - t_{\text{auto},i}) \cdot f_i $$

Cost tracking:

$$ \text{Cost} = N_{\text{calls}} \times \text{avg_tokens_per_call} \times \text{cost_per_token} $$

Built With

Share this project:

Updates