DayQuest

Inspiration

People leave fragments of their day across calendars, messages, development tools, and online services. Individually, these records are useful, but together they are difficult to review as one coherent experience. Combining them also introduces privacy risks because raw personal data may contain identities, locations, financial details, or private message content.

I built DayQuest to explore a different approach: an autonomous agent that reconstructs a day from privacy-safe evidence, visibly reasons about whether the evidence is sufficient, and transforms the final factual timeline into an engaging fantasy story.

The goal was not simply to run several tools in sequence. DayQuest needed a real loop in which every observation could change the next action.

What DayQuest Does

DayQuest receives fragmented event records and creates a chronological, privacy-safe representation of the user’s day.

The agent maintains explicit state and performs a visible loop:

Goal
→ Choose Action
→ Execute Tool
→ Observe Result
→ Evaluate Evidence
→ Continue, Correct, or Stop

During each iteration, the interface displays:

• Action
• Observation
• Decision
• Reason
• Current state
• Evaluation result
• Final stop reason

The agent can continue gathering evidence, reject unsafe records, use fallback data after a tool failure, generate a grounded story, or stop when there is not enough reliable information.

When the timeline passes coverage and privacy checks, DayQuest generates a three-to-five-scene animated fantasy story reel. The fantasy presentation changes, but the underlying event order and factual meaning remain grounded in the normalized timeline.

How I Built It

DayQuest is implemented in Python with a Streamlit interface.

Nexla: Event Normalization

Nexla transforms fragmented source records into one consistent privacy-safe schema containing:

• event ID
• start and end time
• event type
• safe summary
• source
• confidence
• sensitivity
• redaction status

DayQuest reads records from a transformed Nexset, validates every field, removes duplicate event IDs, sorts events chronologically, and rejects unsafe or malformed records.

The real Nexla Samples API returned transformed records inside nested input and output wrappers and included duplicate samples. I implemented bounded extraction, strict field allowlisting, schema validation, privacy checks, and deduplication before the records entered the Agent Loop.

AkashML: Autonomous Motif Selection

After the agent produces a privacy-safe timeline, AkashML selects the fantasy narrative motif.

Supported motifs include:

• Mist Gate
• Clockwork Trial
• Rune Storm
• Sky Caravan
• Mirror Spirit

AkashML controls the narrative atmosphere, while a local grounded renderer preserves event order, factual coverage, and privacy. This prevents the model from inventing or replacing the underlying events.

Pomerium: MCP Privacy Gateway

DayQuest exposes three read-only MCP tools:

• get_safe_day_events
• get_dayquest_privacy_contract
• get_dayquest_status

These tools expose only privacy-safe summaries. They do not expose raw emails, financial records, environment variables, API keys, internal event IDs, local files, or administrative operations.

The MCP server uses Streamable HTTP and listens only on localhost. A live Pomerium pom.run tunnel created an authenticated HTTPS gateway to the local service. An unauthenticated remote request was correctly blocked with HTTP 401.

Local MCP tool discovery and privacy-safe invocation were successfully verified. Authenticated remote tool invocation was not completed in the hackathon environment, so the project does not claim that capability.

Agent Autonomy

DayQuest is not a fixed pipeline.

For example, when Nexla succeeds, the agent uses the normalized remote events and continues to timeline analysis. When Nexla fails, the observation changes the next decision, and the agent selects a safe local fallback. When there are fewer than three reliable key events, the agent refuses to create a misleading story.

The agent stops when:

• factual coverage is sufficient;
• privacy evaluation passes;
• evidence is insufficient;
• a tool repeatedly fails;
• results stop improving;
• the maximum iteration count is reached.

This makes the complete reasoning process visible and auditable.

Animated Story Reel

The final result is displayed as a responsive motion-comic reel.

It includes:

• three to five automatically changing scenes;
• fantasy-themed gradients and visual effects;
• scene titles, time labels, and narration;
• fade transitions and slow motion effects;
• progress indicators;
• a replay control.

The reel is generated entirely from the agent’s final privacy-safe scenes. It does not make additional model calls or send private information to external visual services.

Challenges

The largest challenge was connecting three external systems while preserving one coherent Agent Loop.

Nexla returned wrapped and duplicated sample records. Its normalized event categories also differed from the original local story categories. I solved this with safe nested extraction, event deduplication, and a local canonical category mapping that preserved the original event types.

Akash initially rejected the new Nexla event types during local schema validation. I expanded only the local allowlist while preserving the existing privacy and request logic.

For Pomerium, I needed to expose useful MCP functionality without exposing raw personal data. The final design uses only three narrowly scoped, read-only tools and verifies that unauthenticated remote access is blocked.

Accomplishments

I am proud that DayQuest:

• implements an observation-driven Agent Loop instead of a fixed workflow;
• integrates Nexla, AkashML, and Pomerium;
• uses remote normalized events in the final timeline;
• visibly exposes every action, observation, decision, and stopping reason;
• produces a five-scene animated story reel;
• includes privacy filtering, schema validation, deduplication, and safe fallback behavior;
• passed 116 automated tests;
• was completed as a solo hackathon project.

What I Learned

The most important lesson was that agent autonomy is not defined by how many tools are called. It depends on whether observations actually affect later decisions.

I also learned that external data integrations require much more than a successful HTTP response. Wrapped records, duplicate events, schema differences, privacy restrictions, and failure recovery all need to be handled before the data becomes reliable agent evidence.

Finally, DayQuest showed that generative storytelling can remain creative without allowing the model to alter the underlying facts.

What’s Next

Future work could include:

• authenticated remote MCP tool invocation;
• user-controlled tone, genre, and privacy settings;
• additional privacy-safe data connectors;
• multi-day story continuity;
• richer visual animation;
• controlled evaluation with real personal activity data;
• stronger factual consistency and privacy benchmarks.

Built With

• akash
• context
• model
• nexla
• pomerium
• python
• streamlit