Autonomous Goal Pursuit

Usejarvis includes an autonomous goal pursuit engine — an OKR-style hierarchical goal system with drill-sergeant accountability, daily rhythm, and deep integration with awareness, workflows, and memory.

Overview

Goals in Usejarvis follow the OKR (Objectives and Key Results) framework used by Google, with five levels of hierarchy:

Level	Purpose	Example
Objective	High-level life goal	”Get fit by summer”
Key Result	Measurable outcome	”Run 5K under 25 minutes”
Milestone	Progress checkpoint	”Complete Couch-to-5K program”
Task	Discrete action	”Sign up for local 5K race”
Daily Action	Recurring daily habit	”Morning run”

Google-Style Scoring

Every goal is scored 0.0 to 1.0 using Google’s OKR philosophy:

• 0.0–0.3 — Failed to make real progress
• 0.4–0.6 — Made progress but fell short
• 0.7 — Successfully delivered (this is the target)
• 0.8–1.0 — Over-delivered (you may have aimed too low)

Scores propagate up the hierarchy — child scores roll up to parents automatically.

Creating Goals

Chat (Natural Language)

The simplest way — just tell Usejarvis what you want to achieve:

"I want to get fit by summer"

Usejarvis uses the NL Goal Builder to decompose your statement into a full OKR hierarchy:

Proposed breakdown:
  OBJECTIVE: Get fit by summer
    KEY RESULT: Run 5K under 25 minutes
      MILESTONE: Complete Couch-to-5K program
      DAILY ACTION: Morning run (30min)
    KEY RESULT: Lose 10 lbs
      TASK: Set up calorie tracking app
      DAILY ACTION: Track all meals

You review and confirm. Usejarvis creates the full hierarchy instantly.

Dashboard

Click ”+ New Goal” in the Goals dashboard. Two modes:

1. Natural Language — paste a goal description, Usejarvis proposes the OKR breakdown
2. Quick Create — fill in title, level, parent, description, and deadline manually

API

# Create a goal directly
curl -X POST http://localhost:3142/api/goals \
  -H "Content-Type: application/json" \
  -d '{"title": "Get fit by summer", "level": "objective"}'

# NL decomposition is a two-step flow: propose, then create
curl -X POST http://localhost:3142/api/goals \
  -H "Content-Type: application/json" \
  -d '{"mode": "propose", "title": "I want to learn TypeScript"}'

curl -X POST http://localhost:3142/api/goals \
  -H "Content-Type: application/json" \
  -d '{"mode": "create_from_proposal", "proposal": { ... }}'

Daily Rhythm

Usejarvis runs two daily check-ins driven by configurable time windows:

Morning Plan (default: 7:00)

• Reviews all active goals and their health
• Generates today’s focus areas (which goals need attention)
• Creates daily actions from goals marked as daily habits
• Checks calendar for conflicts
• Delivers the plan via dashboard notification, voice, or Telegram

Evening Review (default: 20:00)

• Collects the day’s progress (manual + auto-detected from screen awareness)
• Scores each daily action as completed or missed
• Updates goal scores based on actual progress
• Generates accountability assessment in drill-sergeant tone
• Identifies goals falling behind schedule

Each check-in fires at the start hour of its window (the end value is not used for scheduling). Configure them from the dashboard’s goal settings; the setting shape is:

goals:
  enabled: true
  morning_window:
    start: 7   # Hour (24h format); the check-in fires at 7:00
    end: 9
  evening_window:
    start: 20  # fires at 20:00
    end: 22
  accountability_style: drill_sergeant  # drill_sergeant | supportive | balanced
  auto_decompose: true
  calendar_ownership: false  # set true to let Usejarvis manage calendar blocks

Accountability & Escalation

The drill sergeant doesn’t let you off easy. When a goal falls behind, Usejarvis escalates through four stages:

Stage	Trigger	Behavior
None	Goal is on track	Normal tracking
Pressure	Behind for 1+ weeks	Daily blunt reminders, increased check-in frequency
Root Cause	Behind for 3+ weeks	LLM analyzes why you’re behind, suggests specific unblocking actions
Suggest Kill	Behind for 4+ weeks	Recommends killing the goal if it’s no longer achievable or relevant

Escalation timing is configurable:

goals:
  escalation_weeks:
    pressure: 1
    root_cause: 3
    suggest_kill: 4

Health Indicators

Each goal has a health status calculated from score progress vs. time elapsed:

• On Track — ahead of or matching expected pace
• At Risk — slightly behind (within 15% gap)
• Behind — significantly behind (15–30% gap)
• Critical — way behind or past deadline with low score

Auto-Detection from Screen Awareness

Usejarvis connects the awareness engine (continuous screen capture + OCR) to your goals. When you’re working on something related to an active goal, Usejarvis automatically detects it:

1. Fuzzy matching — your screen activity (app name, window title, OCR text) is matched against goal descriptions and keywords
2. Auto-progress logging — matched activities are logged as auto_detected progress entries
3. Deduplication — same goal won’t be re-logged within a 30-minute window
4. Evening review — auto-detected progress feeds into the evening review for accurate scoring

Example: If your goal is “Learn TypeScript” and Usejarvis detects you in VS Code editing a .ts file with TypeScript documentation open, it auto-logs progress.

Dashboard

The Goals room offers three switchable views:

Constellation

The default view: your goal hierarchy as a connected map. Each goal shows its level badge, score (0.0 to 1.0), health indicator, and deadline; click through to drill into children.

Timeline

Horizontal bars positioned by start date to deadline:

• Color-coded by health
• Nested rows for child goals
• Today marker line

Metrics

Aggregate charts: overall OKR score, completion, health distribution, and escalations.

Agent Tool

The manage_goals tool is available to Usejarvis in chat for all goal operations:

Action	Description
create	Create a new goal (with optional NL decomposition)
list	List goals filtered by status, level, or parent
get	Get full details of a specific goal
score	Update a goal’s score with reason
update_status	Change status (active, paused, completed, failed, killed)
decompose	Break down a goal into sub-goals using LLM
replan	Generate alternative approaches for a struggling goal
morning_plan	Trigger morning planning session
evening_review	Trigger evening review session
estimate	Get time/effort estimate (hybrid LLM + historical data)
update	Update goal fields
metrics	Aggregate goal metrics
delete	Delete a goal
tree	Full goal tree
overdue	List overdue goals
escalations	List active escalations

Estimation Engine

Usejarvis uses a hybrid estimation approach:

1. Historical data — queries the vault for similar completed goals (matched by tags, level, description)
2. LLM estimation — asks the LLM for an estimate based on the goal description and context
3. Blending — with 2+ similar past goals: 60% historical, 40% LLM. With exactly one: 40% historical, 60% LLM. With none: 100% LLM.

Each estimate includes:

• Hours estimate (with confidence interval)
• Confidence level (low/medium/high)
• Reasoning explanation
• Similar past goals used as reference

Goal Memory

When a goal is completed, failed, or killed, Usejarvis extracts it into the vault as a knowledge entity with performance facts:

• Final score
• Estimated vs. actual hours
• Time to complete
• Estimation accuracy ratio
• Tags and level

This builds a growing dataset that improves future estimations and gives Usejarvis historical awareness of your track record.

API Reference

Endpoints

Method	Path	Description
GET	/api/goals	List goals (query: status, level, parent_id)
POST	/api/goals	Create goal
GET	/api/goals/:id	Get goal by ID
PATCH	/api/goals/:id	Update goal fields
DELETE	/api/goals/:id	Delete goal
GET	/api/goals/roots	Top-level goals
GET	/api/goals/overdue	Overdue goals
GET	/api/goals/:id/children	Direct children
POST	/api/goals/:id/score	Update score with reason
POST	/api/goals/:id/status	Change status
GET	/api/goals/:id/health	Health assessment

Decompose, replan, morning plan, and evening review are triggered through the manage_goals agent tool (ask in chat), not via dedicated REST routes.

WebSocket Events

Goal events are broadcast via WebSocket (same connection as other Usejarvis events):

{
  "type": "goal_event",
  "timestamp": 1709654400000,
  "payload": {
    "type": "goal_scored",
    "goalId": "abc123",
    "data": { "score": 0.45, "reason": "Completed 3 of 5 subtasks", "source": "user" },
    "timestamp": 1709654400000
  }
}

Event types include goal_created, goal_updated, goal_scored, goal_completed, goal_failed, goal_killed, goal_escalated, check_in_morning, and check_in_evening.

Example: Create and Score

# Create an objective
GOAL_ID=$(curl -s -X POST http://localhost:3142/api/goals \
  -H "Content-Type: application/json" \
  -d '{"title": "Ship v1.0", "level": "milestone", "description": "Release version 1.0 to production"}' \
  | jq -r '.id')

# Score it
curl -X POST "http://localhost:3142/api/goals/$GOAL_ID/score" \
  -H "Content-Type: application/json" \
  -d '{"score": 0.4, "reason": "Core features done, testing remains"}'

# Check health
curl "http://localhost:3142/api/goals/$GOAL_ID" | jq '.health'

Configuration Reference

Goal settings are managed from the dashboard and stored in the settings database (a legacy goals: block in config.yaml is imported once at boot). The full shape and defaults:

goals:
  enabled: true

  # Daily rhythm windows (24h format); each check-in fires at the start hour
  morning_window:
    start: 7
    end: 9
  evening_window:
    start: 20
    end: 22

  # Accountability tone
  accountability_style: drill_sergeant  # drill_sergeant | supportive | balanced

  # Escalation timing (weeks behind before each stage)
  escalation_weeks:
    pressure: 1
    root_cause: 3
    suggest_kill: 4

  # Auto-decompose goals into daily actions
  auto_decompose: true

  # Let Usejarvis create/move calendar events for goals
  calendar_ownership: false