Alexa+: Autonomous Mission Execution Platform

Activity

What Inspired Us

Most voice and conversational assistants remain constrained to isolated commands, simple reminders, or superficial chat responses. When a user presents a genuine, high-level real-world objective—such as "Prepare me for tomorrow's product review"—traditional assistants hit an immediate wall. They either force the user to manually stitch together every step across multiple applications or generate convincing but ungrounded answers.

We wanted to build something fundamentally different: an agentic mission system that turns a high-level objective into a verified sequence of actions across multiple services.

We recognized that the Model Context Protocol (MCP) provides the ideal standardized interface for exposing rich capabilities to autonomous models. Rather than hardcoding APIs into fragile prompts, we set out to build an architecture where an assistant independently determines the services it needs, executes a structured multi-tool chain over modern Streamable HTTP, validates collected evidence, and delivers a rigorous, executive-ready preparation briefing.

What It Does

When a user gives Alexa+ a high-level mission:

"Prepare me for my Alexa+ product review tomorrow. Check my calendar, find the relevant emails, locate the relevant documents in Drive, identify what I haven't prepared, and create a preparation checklist."

The system doesn't generate a conversational guess. It executes an autonomous 5-stage lifecycle:

Understand: Decomposes the high-level intent, extracts temporal bounds (e.g. tomorrow's schedule), and determines the required service domains: Calendar + Email + Documents.
Plan: Formulates an executable multi-service Directed Acyclic Graph (DAG) specifying tool dependencies and data flow.
Execute Multi-Service MCP Tool Chain: Connects to an independent, self-hosted Model Context Protocol server over modern Streamable HTTP (:3001/mcp) and autonomously executes:
- calendar_get_events: Locates the scheduled review, meeting platform, and attendee list.
- gmail_search: Discovers related discussion threads and recent stakeholder exchanges.
- drive_search: Finds pertinent architecture and roadmap files in Google Drive.
- drive_get_file: Fetches live Google Docs content via plain-text export.
- document_analyze: Deeply parses document text to extract core topics, decisions needed, unresolved dependency risks, and preparation gaps.
Evidence Fusion & Verification: Cross-references calendar details with email correspondence and exported document contents to detect discrepancies and unaddressed items.
Synthesize Result: Produces a structured briefing containing:
- Meeting Schedule & Context
- Relevant Email Intelligence
- Relevant Google Drive Assets
- Key Decisions Needed
- Critical Technical Risks & Dependencies
- Action Items & Meeting Preparation Checklist

The result is grounded in evidence retrieved through the executed MCP tools.

Dual-Mode Execution Architecture

To guarantee technical rigor for enterprise deployments and seamless evaluation for hackathon judges:

Enterprise Live Mode: Authenticated Google Workspace integrations (Google Calendar, Gmail, Google Drive with live Google Doc export) via OAuth 2.0 with AES-256-GCM encrypted token persistence.
Transparent Evaluation Mode (Zero-Key Frictionless Review): When external OAuth authorization is not configured, the self-hosted MCP server transparently uses a local SQLite dataset, explicitly attributing the source as Local MCP Dataset (Unauthenticated Local Fallback). Evaluators can test every feature without configuring third-party credentials.

How We Built It

Model Context Protocol (MCP) Server: Built an independent microservice using @modelcontextprotocol/sdk (^1.32.1) operating over Streamable HTTP (:3001/mcp, spec 2025-11-25+). It exposes 11 registered domain tools with strict Zod schema validation (with 5 executed sequentially in the hero mission).
Multi-Service Agent Orchestrator: Implemented a resilient DAG execution engine featuring dynamic runtime tool discovery via JSON-RPC tools/list, schema-driven parameter binding, and live telemetry streaming via Server-Sent Events (SSE).
Amazon Bedrock Converse Integration: Integrated @aws-sdk/client-bedrock-runtime using Bedrock's native ConverseCommand structured tool-calling API, supporting Anthropic Claude 3.5 Sonnet and Amazon Nova Pro, paired with a resilient local deterministic fallback ensuring 100% keyless evaluation on cloud deployments.
Google Workspace Multi-Tool Integration: Connected real Google Calendar, Gmail, and Google Drive APIs with AES-256-GCM token encryption, handling live Google Docs export (exportView) for direct document text analysis.
Authoritative Persistence Store: Structured relational SQLite database (better-sqlite3) tracking missions, execution steps, tool call traces, document indices, and audit events.
Frontend Mission Workspace: Built with React 19, TypeScript, and modern CSS featuring live SSE event timelines, an interactive raw MCP Tool Runner, knowledge management, and connected service toggles.
Companion Open-Source Package: Developed and published mcp-session-reaper (MIT License) to manage SSE socket lifecycles and eliminate orphaned connections in Streamable HTTP servers.

Challenges We Ran Into

Streamable HTTP Session & Socket Lifecycle Management: Operating MCP over HTTP rather than stdio pipes introduced socket leakage when SSE streams were interrupted. We solved this by developing mcp-session-reaper, a dedicated middleware that scavenges idle sockets and cleanly closes sessions.
Ephemeral Cloud Storage & Dynamic Token Recovery: Hosting on modern cloud containers with ephemeral filesystems meant OAuth refresh tokens could be wiped during container resets. We hardened token persistence with resilient schema recovery, multi-capability detection, and transparent fallback attribution.
Cross-Service Multi-Tool Data Correlation: Passing outputs from calendar_get_events into gmail_search, and resolving Drive file metadata into raw text export via drive_get_file before calling document_analyze required strict intermediate data modeling and schema normalization.

Accomplishments That We're Proud Of

Genuine Multi-Service Execution: Successfully demonstrated a controlled real-service test scenario executing 5 distinct MCP operations across Google Calendar, Gmail, Google Drive, and deep document parsing in 3.6 seconds.
Self-Hosted Streamable HTTP MCP Implementation: Full compliance with the official MCP 2025-11-25+ specification, including an in-browser Interactive MCP Tool Runner with millisecond latency tracking.
Dual-Mode Transparency: Maintained complete technical honesty by explicitly distinguishing between live OAuth sources and unauthenticated local fallbacks in the UI.
100% Test Verification: 17 automated test suites passing with 100% success, covering security controls, concurrency isolation, Bedrock Converse integration, and failure recovery.
Open-Source Contribution: Authored packages/mcp-session-reaper to solve socket hanging for the wider MCP community.

What We Learned

MCP is the Missing Link for Agents: MCP decouples model reasoning from tool implementation. Building the tool interface as an independent HTTP service allows different models (Bedrock, Nova, Claude) to interact with enterprise capabilities identically.
Grounding Requires Multi-Source Evidence Fusion: Single-source answers are fragile. Grounding an assistant requires pulling schedule data, matching it to communications, and analyzing primary source documents.
Production Server Hygiene is Critical for Streamable HTTP: HTTP-based agent communication requires robust session tracking and socket reaping to avoid memory degradation.

What's Next for Alexa+

Expanding MCP server integrations to enterprise ticketing (Jira, Linear) and communication platforms (Slack, Teams).
Implementing multi-agent delegation where specialized sub-agents independently research different aspects of a mission in parallel.
Integrating proactive push notifications so Alexa+ alerts users when meeting agendas change or critical preparation gaps are detected ahead of time.

Built With

aes-256-gcm
amazon-bedrock
amazon-nova-pro
anthropic-claude-3.5-sonnet
bedrock-converse-api
better-sqlite3
express.js
gmail-api
google-calendar-api
google-drive-api
mcp-sdk
model-context-protocol-(mcp)
node.js
oauth-2.0
react-19
server-sent-events-(sse)
sqlite
streamable-http
tailwind-css
typescript
zod

Submitted to

Build, Ship, Shape: Amazon Developer Hackathon

Created by

I led the development of **Alexa+: Autonomous Mission Execution Platform**, taking the project from architecture and implementation to testing and hackathon submission.

My contributions included designing the system architecture, building the autonomous agent orchestrator, and implementing a self-hosted Model Context Protocol (MCP) server using Streamable HTTP. I developed the five-stage mission lifecycle—Understand, Plan, Execute, Verify, and Synthesize—and integrated tool discovery, multi-step execution, Server-Sent Events (SSE) for real-time progress, and SQLite persistence.

I also worked on the React and TypeScript frontend, including the mission workspace, interactive MCP tool runner, knowledge management, integrations hub, activity timeline, and settings. I integrated Amazon Bedrock Converse API support for Anthropic Claude 3.5 Sonnet and Amazon Nova Pro, with a local deterministic fallback for evaluation.

Additionally, I created **mcp-session-reaper**, an MIT-licensed open-source utility to help manage stale sessions and socket cleanup in MCP Streamable HTTP servers. I worked on automated testing, error handling, security, execution transparency, documentation, and deployment readiness to make the prototype reproducible and easier for judges to evaluate.

Shanmukheswar Medicharla