Gapwise

Gapwise is an agentic project assistant that brings wisdom to the gaps in your work. It identifies which missing answer, unresolved decision, or dependency matters most right now, and explains why.

Comment 1

Inspiration

Projects now collect information from documents, conversations, research, meetings, and generated content, people need executive intelligence to achieve their goals.

The difficult part is turning all that context into direction:

  • What information is still missing?
  • Which decision is blocked?
  • What issue has the greatest effect on the project?
  • What should happen next?

What it does

Gapwise builds a persistent understanding of a project and helps the user identify:

  • Important unanswered questions
  • Open decisions
  • Risks and constraints
  • Dependencies and blockers
  • The most useful next focus

As the user adds context, answers questions, or confirms decisions, Gapwise updates its project understanding and recommendations.

How we built it

Project architecture

Gapwise is split into two deployed services:

  • A Next.js application containing the interface, APIs, project workflows, and persistence layer.
  • A private Python Google ADK service containing the conversational and research agents.

Both services run on Google Cloud Run and are deployed through Cloud Build.

User input
    ↓
Gemini context processing
    ↓
Validated structured project updates
    ↓
Persistent project graph in Firestore
    ↓
GraphRAG retrieval
    ↓
Google ADK agents
    ↓
Gap, focus, answer, or recommendation

Structured project understanding

Users can add:

  • Notes
  • PDF documents
  • Ask conversations
  • Question answers
  • Confirmed decisions
  • Google Calendar commitments

Gemini on Vertex AI interprets new context and returns structured project updates.

These updates can contain:

  • Goals
  • Facts and evidence
  • Constraints
  • Preferences
  • Risks
  • Assumptions
  • Unknowns
  • Decisions
  • Next actions
  • Relationships between project items

The application validates these updates before modifying the project.

This prevents a model response from directly becoming project truth without passing through the project's schemas, reconciliation rules, and user-confirmation workflows.

Project graph

Gapwise represents project understanding as a graph.

Nodes describe project items such as:

UNKNOWN
Can customer data be deleted within 30 days?

CONSTRAINT
Security approval is required before procurement.

DECISION
Choose the technical integration scope.

NEXT_ACTION
Run the production access rehearsal.

Edges describe relationships such as:

supports
informs
affects
blocks
depends_on
satisfies
contradicts
supersedes

A simplified project path might be:

Data-deletion capability
    ↓ informs
Security approval
    ↓ blocks
Procurement
    ↓ affects
Launch date

Relationship validation prevents unsupported or structurally invalid connections from being stored.

GraphRAG

Gapwise uses a lightweight GraphRAG pipeline. RAG (Retrieval-Augmented Generation). It retrieves relevant project information before Gemini generates a response. For each request, Gapwise:

  1. Selects up to five relevant graph nodes using lexical relevance.
  2. Follows relationships such as blocks, depends_on, informs, and affects for one or two hops.
  3. Retrieves supporting excerpts from the original sources.
  4. Sends a bounded Context Pack of nodes, paths, and evidence to the selected agent. For example, a pricing question could retrieve this path: Supplier evidence → unresolved cost estimate → blocks pricing decision → affects launch

This gives the agent the project context and supporting evidence needed for the response.

Google ADK agents

Gapwise uses four specialized agents built with Google ADK.

Gap Agent

Evaluates unresolved questions and selects the gap with the highest decision value.

It considers factors such as:

  • Downstream impact
  • Blocked decisions
  • Available evidence
  • Answerability
  • Project urgency

Ask Router

Classifies each Ask request and selects one of three paths:

  • Saved project context
  • Graph reasoning
  • Live web research

Partner Agent

Uses the retrieved project context to:

  • Explain recommendations
  • Compare options
  • Discuss tradeoffs
  • Answer project questions
  • Help the user work through decisions

Web Research Agent

Uses Google Search when the answer requires current or external information.

Grounded research remains separate from confirmed project information until the user chooses to save it or use it as an answer.

Attention and recommended focus

Gapwise maintains a shared Focus Assessment for Today and Ask.

The assessment considers:

  • Goal alignment
  • Impact
  • Urgency
  • Unresolved risk
  • Evidence confidence
  • Actionability
  • Effort
  • Dependencies and blockers

Blocked decisions are sequenced behind their unresolved prerequisites. Resolved actions are removed from consideration so they do not continue appearing as recommendations.

Persistence and history

Firestore stores:

  • Projects
  • Graph nodes and relationships
  • Ask conversations
  • Answers and decisions
  • Focus and overview assessments
  • User memory
  • Project history
  • Immutable project snapshots

Cloud Storage stores original uploaded documents and generated demo files.

Each meaningful project change can create a snapshot. Users can inspect the project at an earlier moment or create a separate project branch from that state.

Deployment and observability

The production system uses:

  • Cloud Run for the web and private ADK services
  • Vertex AI for Gemini
  • Firestore for structured project state
  • Cloud Storage for uploaded files
  • Cloud Build for container builds and deployment
  • Secret Manager for runtime credentials
  • Cloud Trace for ADK execution traces

Gapwise also provides a localhost Developer Trace showing:

  • Selected agent
  • Routing decision
  • Retrieved graph nodes
  • Relationships
  • Supporting evidence
  • Model configuration
  • Execution latency

Challenges we ran into

Maintaining one consistent project state

Today, Ask, Workspace, and the Decision Map must all use the same understanding of the project.

Independent recommendations created conflicting priorities, so we introduced a shared Focus Assessment.

Distinguishing evidence from decisions

A preference or recommendation can support a decision without resolving it.

Decisions only become resolved after an explicit user commitment or confirmation.

Managing graph changes over time

Resolving a decision can satisfy related actions and unblock later work.

We needed completion propagation so stale actions would not remain open or continue appearing as recommendations.

Preventing duplicate questions

Model-generated questions and deterministic fallbacks could describe the same uncertainty differently.

Gapwise combines those versions into one canonical question while keeping the sources that produced them.

Keeping generated assessments current

Overview, Today, and Ask suggestions are saved by semantic project version.

This allows the interface to reuse valid assessments while refreshing them only when meaningful project understanding changes.

Accomplishments that we're proud of

Decision Map

The Decision Map connects facts, gaps, risks, actions, and decisions.

It helps users see:

  • Why a gap matters
  • Which decision it informs
  • What it blocks
  • Which goal it affects
  • Where the supporting evidence came from

Shared project reasoning

Today and Ask use the same Focus Assessment, keeping project priorities consistent across the product.

Reproducible history

Project snapshots preserve context, graph state, conversations, answers, recommendations, and proposal status at meaningful moments.

A user can inspect an earlier state or create a new project branch from it.

What we learned

Building the graph also required preserving what each fact meant as decisions and project conditions changed.

We learned that:

  • Evidence can support a decision without resolving it.
  • A high-impact decision may still be the wrong next focus when a prerequisite blocks it.
  • Completed outcomes must close their related actions.
  • Recommendations need provenance, but provenance is not always the actionable target.
  • Caches should change when project meaning changes, not whenever a timestamp or database record changes.
  • Every product surface must reason from the same project state.

We now treat project state, sequencing, and user confirmation as separate parts of the system.

What's next for Gapwise

Planned directions include:

  • More document and productivity integrations
  • Shared workspaces with multiple collaborators
  • Several active workspaces viewed together
  • Workspace roles and permissions
  • IDE integrations
  • Connections with coding agents
  • Project updates generated from development activity
  • Background monitoring for changed dependencies and new risks
  • Better evaluation of long-running project outcomes

Built With

Share this project:

Updates

Submission history