OutcomeDev | The AI Task Engine

OutcomeDev keeps you informed about your tasks with a real-time notification system. Never miss a completed task, a created pull request, or an error that needs your attention.

Notification Bell

The bell icon in the top-right corner of the app shows your notifications at a glance:

A red badge appears when you have unread notifications, showing the count
Click the bell to open the notification panel, a dropdown showing your recent activity
Each notification shows the event type, a brief description, and when it happened

Notification Types

Type	Icon	When It Triggers
Task Completed	✓ (green)	Your agent successfully finished a task
Pull Request Created	PR (blue)	A pull request was opened for your task
Task Error	✕ (red)	Something went wrong during task execution

Managing Notifications

Reading Notifications

Click any notification to mark it as read and jump directly to the relevant task
Use the "Mark all read" button at the top of the panel to clear all unread notifications at once

Real-Time Updates

Notifications appear automatically as the system checks for new updates every 30 seconds. When you're viewing an active task, Server-Sent Events (SSE) deliver status changes instantly, so you see completion and errors the moment they happen.

How It Works

When a task finishes (successfully or with an error), or when a pull request is created, OutcomeDev automatically creates a notification for you. These notifications persist in the database, so you won't lose them if you close the browser or switch devices.

The notification includes:

The type of event (completion, PR, or error)
A brief excerpt of the task prompt so you know which task it relates to
A link to the task page for full details

Tips

Check the bell regularly, it's the fastest way to see what your agents have accomplished while you were away.
Click through to tasks, notifications link directly to the task detail page where you can review the work, see the PR, or retry if there was an error.
Stay in flow, with real-time SSE updates, you don't need to constantly refresh the page to see if your task is done.

Developer Notifications API

OutcomeDev exposes a high-end API that allows your external tools, CI/CD pipelines, and custom scripts to push actionable alerts directly to your dashboard.

1. Generating API Tokens

To use the Notifications API, you must first issue a developer token:

Navigate to Settings > Developer.
Click "Create API Key" and give it a name.
Copy your key (otk_live_...) and store it securely. For security, we never show the full key again.

2. Pushing Notifications

Send a POST request to https://outcomedev.com/api/v1/notify with the X-Outcome-API-Key header.

Request Body (JSON)

Field	Type	Required	Description
`title`	`string`	Yes	The headline of the notification.
`body`	`string`	Yes	The detailed message or error log.
`type`	`string`	No	`developer_event` (default) or `app_alert`.
`metadata`	`object`	No	Context for holistic actions (see below).

Metadata Object Details

The metadata object is optional but enables the Holistic Actions. You can include:

repoUrl: The full GitHub URL for the repository to be fixed.
taskId: The ID of the task to target for interjections or reactivation.
suggestedPrompt: An AI-optimized prompt to pre-fill the Task Form.
sandboxRefId: Force the reuse of a specific sandbox environment.

5. Ecosystem Use Cases (Start vs. Inject)

Scenario	Trigger	Type	Result
Security Guardian	Snyk CVE Found	Start Task	User clicks notification; Agent fixes CVE in fresh sandbox.
Infra Scaler	Traffic Spike	Inject	Active SRE agent is interrupted to scale Kubernetes replicas.
Agent Swarm	Task Hand-off	Inject	Architect agent triggers Tester agent to start unit tests.
Deployment Audit	Vercel Success	Start Task	User clicks notification; Agent audits staging site performance.
Mid-Sprint Pivot	Jira Update	Inject	Active agent stashes work to incorporate new requirements.

7. Form Hydration: Context-Aware UI

"Hydration" is the process of pre-filling the OutcomeDev UI with metadata from a notification. This reduces cognitive load to zero.

Scenario: The "One-Tap" Bug Fix

Event: GitHub Action fails on main.

API Call:

{
  "title": "CI Failure: main branch",
  "body": "Tests failed in src/auth.ts",
  "metadata": {
    "repoUrl": "https://github.com/org/repo",
    "suggestedPrompt": "Fix the test failures in auth.ts"
  }
}

Result: The user sees the notification. Clicking "Start Task" opens a Task Form where the repo is already selected and the prompt is already written. The user just clicks "Execute."

8. Standard (Static) Notifications

Not every notification needs an agent. Sometimes you just want to inform the human.

Scenario: Deployment Success

Event: Vercel finishes a production deployment.

API Call:

{
  "title": "Deployment Success",
  "body": "v1.2.4 is now live in production.",
  "type": "app_alert"
}

Result: A simple, persistent alert appears in the notification center. No "Start Task" button is shown because no metadata was provided. It is a Static Informational Alert.

10. Advanced Hydration: Staged Re-entry

You can pre-configure the exact sandbox environment for a user, effectively bypassing the "Task Setup" phase.

Metadata Fields:

taskId: Links the new turn to an existing conversation.
sandboxRefId: Pre-selects the specific durable workspace to reuse.

Scenario: The "Context-Preserving" Follow-up

Event: An agent finishes a task but a downstream test fails.

API Call:

{
  "title": "Tests Failed after Commit",
  "body": "Your recent changes broke the /api/auth endpoint.",
  "metadata": {
    "repoUrl": "...",
    "taskId": "original-task-id",
    "sandboxRefId": "original-sandbox-id",
    "suggestedPrompt": "Fix the breaking changes in auth.ts while staying in the current environment."
  }
}

Result: When the user clicks "Start Task", the Task Form is pre-configured to Reuse Sandbox. The user is one click away from being back in the exact terminal session where the error occurred.

{
  "title": "CI Regression: Auth Logic",
  "body": "Commit 4f8e2 failed integration tests. Agent is staged for investigation.",
  "type": "developer_event",
  "metadata": {
    "repoUrl": "https://github.com/org/repo",
    "taskId": "task-abc-123",
    "sandboxRefId": "sandbox-xyz-789",
    "suggestedPrompt": "Investigate the integration test failure in auth_test.go."
  }
}

3. Holistic Actions: Compute Lifecycle Mapping

When a developer notification arrives, you can route it to different compute contexts:

You want to...	Metadata Needed	UI Action	Result
Start Fresh	`body`	Start Task	Opens Task Form. Fresh sandbox created.
Continue Work	`repoUrl` + `taskId`	Start Task	Opens Task Form. Workspace/Files reused.
Pivot Agent	`taskId` (active)	-	(Real-time injection handled via API).
Wake Up Agent	`taskId` (stopped)	-	(Reactivation handled via API).

4. Advanced: The "Smart Pivot" (Injection)

The most powerful feature of the Notifications API is Real-Time Injection. If you provide a taskId in the metadata of a notification, the system will inject the body of that notification directly into the active task's chat history.

Scenario:

Agent is working on Task A (Low Priority).
Your monitoring script detects a Critical Bug.
The script calls the API targeting Task A.
The Agent is interrupted, reads the new alert, and pivots its reasoning to address the critical bug within the same sandbox.

This allows for seamless, automated reprioritization of your agent workforce without human intervention.

OUTCOME_TASK_ID: Links to the current active mission.
OUTCOME_SANDBOX_ID: Links to the durable workspace (the original creator task).

Pro Tip: The API is fully decoupled. While your scripts can use these defaults to report back to their "parent" task, they can target any task by simply passing a different taskId in the metadata.