ScoutOS is an autonomous opportunity agent built for a sponsor-heavy hackathon demo.

It watches external opportunity signals, restores durable user context, evaluates fit and urgency automatically, chooses an action without waiting for a manual prompt, and leaves a clear audit trail behind.

People miss valuable opportunities because the intake stream is noisy, fragmented, and too manual. Hackathons, grants, scholarships, internships, accelerators, and fellowships all arrive from different places, and most teams do not have time to constantly monitor, triage, and act on them.

ScoutOS solves that by behaving like an autonomous operating layer:

• it watches incoming opportunities
• it remembers what matters to the user
• it evaluates fit automatically
• it takes the next action
• it stores what happened

ScoutOS automatically finds and acts on the right opportunities for you.

ScoutOS is designed to make this loop obvious in both the product and the code:

INPUT -> CONTEXT -> EVALUATE -> ACT -> REMEMBER

• INPUT: a new opportunity arrives through the Nexla-backed ingestion adapter or the demo control panel
• CONTEXT: ScoutOS restores user preferences, learned signals, and reusable skill metadata from Senso when available
• EVALUATE: the reusable opportunity evaluation skill scores relevance, urgency, estimated value, and preference fit
• ACT: ScoutOS chooses one of four actions: ignore, save to shortlist, mark high priority, or draft next-step summary
• REMEMBER: the action is written to memory and shown in the visible audit trail

• Autonomous opportunity intake with Nexla-backed webhook delivery and mock fallback
• Hybrid ingestion that can normalize real public opportunity URLs through Gemini on the control page
• Durable user preference memory through Senso with fallback-safe local memory
• A reusable opportunity evaluation skill that can be described as a Senso skill boundary
• Automatic action selection with visible reasons and assistant-ui workflow traces
• A demo-safe control page for injecting new opportunities and replaying the agent loop

• Senso
  • Role: memory, context restore, reusable skill metadata, action logging
  • Visible proof: /setup, /memory, audit trail, control-page workflow
• Nexla
  • Role: external opportunity ingestion and webhook delivery
  • Visible proof: /control, /activity, Nexla sync indicators, audit trail
• assistant-ui
  • Role: operator-facing workflow interface and visible autonomy layer
  • Visible proof: /control operator console, live action trace, /activity workflow panels and tool cards

ScoutOS is split into four layers:

1. Presentation layer

   • app/*
   • components/scout/*
   • components/ui/*

2. Agent orchestration layer

   • lib/scout-agent.ts
   • coordinates intake, memory restore, evaluation, action selection, and audit trail generation

3. Sponsor adapter layer

   • lib/integrations/senso.ts
   • lib/integrations/nexla.ts
   • lib/integrations/gemini-opportunity-extractor.ts
   • keeps sponsor-specific logic isolated behind fallback-safe interfaces

4. Domain and demo layer

   • lib/skills/opportunity-evaluation-skill.ts
   • lib/scout-helpers.ts
   • data/mock-opportunities.ts
   • data/mock-memory.ts

• /
  • landing page with value prop, sponsor mapping, autonomy loop, and demo story
• /setup
  • preference form for keywords, categories, urgency threshold, location preference, and opportunity types
• /activity
  • ranked incoming opportunities with evaluation output, autonomous action, and assistant-ui trace
• /memory
  • stored preferences, saved opportunities, rejected opportunities, and action history
• /control
  • primary live demo surface for queue replay, custom opportunity injection, evaluation, and trace inspection

Use .env.example as the starting point, then paste real credentials into scoutos/.env.local.

NEXT_PUBLIC_APP_URL=http://localhost:3000
SCOUTOS_DATA_MODE=hybrid
SENSO_API_KEY=
SENSO_WORKSPACE_ID=scoutOS
SENSO_SKILL_PROMPT_ID=
SENSO_BASE_URL=https://sdk.senso.ai/api/v1
NEXLA_API_KEY=
NEXLA_FLOW_ID=
NEXLA_WEBHOOK_URL=
NEXLA_SAMPLE_COUNT=8
NEXLA_BASE_URL=https://api.nexla.com
GEMINI_API_KEY=
GEMINI_MODEL=gemini-2.5-flash

Also supported:

NEXLA_ACCESS_TOKEN=
NEXLA_DATA_SET_ID=

• NEXT_PUBLIC_APP_URL
  • public app URL used by the app and docs
• SCOUTOS_DATA_MODE
  • mock, hybrid, or live
  • recommended: hybrid
• SENSO_API_KEY
  • server-side auth for Senso
• SENSO_WORKSPACE_ID
  • ScoutOS memory namespace for preferences and action logs
• SENSO_SKILL_PROMPT_ID
  • optional Senso prompt binding for the reusable evaluation skill
• SENSO_BASE_URL
  • Senso API base URL
• NEXLA_API_KEY
  • Nexla credential alias supported by the adapter
• NEXLA_FLOW_ID
  • Nexla dataset or flow identifier alias supported by the adapter
• NEXLA_WEBHOOK_URL
  • Nexla webhook endpoint used when ScoutOS emits a new opportunity
• NEXLA_SAMPLE_COUNT
  • optional preload count for live opportunity polling
• NEXLA_BASE_URL
  • Nexla API base URL
• GEMINI_API_KEY
  • server-side Gemini key used only for real public URL normalization
• GEMINI_MODEL
  • fast Gemini model for structured opportunity extraction

1. Install dependencies.

npm install

2. Copy the env template.

cp .env.example .env.local

3. Paste real credentials into scoutos/.env.local.

4. Start the app.

npm run dev

5. Open http://localhost:3000.

ScoutOS is intentionally demo-safe.

• If Senso is available, it becomes the primary memory layer.
• If Senso fails, ScoutOS falls back to local mock memory without breaking the UI.
• If Nexla live ingest is available, ScoutOS can preload live opportunity samples.
• If Nexla live ingest fails, ScoutOS falls back to the mock opportunity queue.
• If Nexla webhook delivery fails, ScoutOS logs the failure, shows it in the UI, and keeps the local agent loop running.
• If real public URL fetch or Gemini normalization fails, ScoutOS falls back to the mock opportunity queue and preserves the existing full-auto demo path.

hybrid mode is the recommended hackathon mode because it keeps sponsor usage visible while preserving stability on stage.

• lib/integrations/senso.ts

  • saves preferences
  • restores preference context for evaluation
  • logs agent actions
  • exposes reusable skill metadata

• lib/integrations/nexla.ts

  • loads live opportunities when configured
  • POSTs emitted opportunities to NEXLA_WEBHOOK_URL
  • falls back to mock opportunities if Nexla is unavailable

• lib/integrations/gemini-opportunity-extractor.ts

  • fetches a real public opportunity page
  • extracts readable page content server-side
  • asks Gemini for structured ScoutOS opportunity JSON
  • falls back safely if fetch or normalization fails

• lib/skills/opportunity-evaluation-skill.ts

  • reusable evaluation skill boundary used by the autonomous loop

• lib/scout-agent.ts

  • orchestrates the full ScoutOS cycle and builds the audit trail

• app/api/demo/trigger/route.ts

  • emits the next queue item, a manually injected opportunity, or a Gemini-normalized real public opportunity through the Nexla adapter

• app/api/demo/evaluate/route.ts

  • runs the autonomous evaluation cycle

• components/scout/operator-console.tsx

  • assistant-ui operator console

• components/scout/assistant-workflow-panels.tsx

  • assistant-ui workflow traces, tool cards, and action visibility

1. Open /setup

   • show the saved preference profile
   • explain that ScoutOS acts from durable memory, not a one-off prompt

2. Open /control

   • paste a public opportunity URL, click Load Real Opportunity, or use Load Real Example
   • alternately inject a custom opportunity or emit the next queue item
   • show the opportunity immediately appear as an inbound external signal

3. Run the full autonomous cycle

   • ScoutOS restores context
   • evaluates fit and urgency
   • chooses an action
   • writes the result to memory

4. Pause on the assistant-ui trace

   • show Nexla input
   • show Senso context restore
   • show evaluation
   • show action selection
   • show memory writeback

5. Open /activity

   • show multiple outcomes across the feed
   • ignored
   • saved
   • high priority
   • drafted next-step summary

6. End on /memory

   • prove the profile, history, and stored actions persist beyond a single interaction

• Senso payload handling is defensive because tenant-specific response shapes can vary.
• Nexla live polling is supported, but the demo is optimized around webhook-backed emission plus safe fallback.
• Memory is fallback-safe, but not yet backed by a separate database outside the sponsor integration layer.
• The operator console is intentionally read-only and deterministic; it is there to explain the autonomous system, not replace it with chat.

• The user sets preferences once.
• New external opportunities can arrive without a chat prompt.
• ScoutOS evaluates them against stored context automatically.
• The system chooses a meaningful action on its own.
• Every step is visible and remembered.

That is the core demo story: ScoutOS automatically finds and acts on opportunities for you.