Routine Prediction

By analyzing user events and documents over time, the Fastino Personalization API builds a continuous model of daily and weekly rhythms — identifying focus windows, rest periods, and behavioral cycles.

Overview

Routine prediction helps your agents:

• Suggest tasks or messages at the right time.

• Avoid interruptions during deep work or off-hours.

• Anticipate recurring behaviors (e.g., Monday stand-ups, Friday reviews).

• Adapt scheduling and notification timing dynamically.

This turns AI systems from reactive responders into proactive coordinators aligned with each user’s natural rhythm.

Key Components

Example: Ingesting Activity Events

Each user’s event history feeds the temporal model.

POST /ingest
{
  "user_id": "usr_42af7c",
  "source": "calendar",
  "events": [
    {
      "event_id": "evt_1",
      "type": "meeting",
      "timestamp": "2025-10-27T09:00:00Z",
      "content": "Weekly sync with design team"
    },
    {
      "event_id": "evt_2",
      "type": "task_completion",
      "timestamp": "2025-10-27T11:30:00Z",
      "content": "Completed draft of investor update"
    }
  ]
}

Fastino detects recurring timing patterns across these events to build temporal embeddings.

Example: Querying Routine Predictions

Agents can query routine forecasts directly:

POST /query
{
  "user_id": "usr_42af7c",
  "question": "When is Ash usually most productive?"
}

Response

{
  "answer": "Ash’s highest productivity occurs between 9 AM and 12 PM PT, with a secondary focus window from 8 PM to 10 PM."
}

Example: Predicting Next Likely Action

POST /query
{
  "user_id": "usr_42af7c",
  "question": "What is Ash likely to work on next based on recent activity?"
}

Response

{
  "answer": "Ash typically reviews engineering updates on Tuesdays after lunch. Next likely action: reviewing sprint summaries."
}

This predictive reasoning allows assistants to plan timing and actions intelligently.

Example: Retrieving Routine Summary

Agents can retrieve deterministic, LLM-ready summaries of user schedules and behavioral windows.

Response

{
  "summary": "Ash’s focus windows are 9–12 PT and 8–10 PM. Meetings preferred after 1 PM. Low responsiveness on Fridays after 3 PM."
}

This summary can be used by scheduling agents, productivity bots, or proactive assistants.

How It Works

Fastino’s temporal analysis model clusters and aggregates user activity data:

1. Ingest events with timestamps.

2. Analyze periodicity, recency, and tool type.

3. Infer temporal embeddings (daily/weekly cycles).

4. Expose predictions through /profile/query and /profile/summary.

5. Adapt to changes as new data arrives.

All predictions remain deterministic and explainable — no black-box behavior.

Example: Temporal Adaptation Over Time

1. Early user data:

   • “Focus 9–12 PT.”

   • “Meetings after 1 PM.”

2. After a role change (logged via /ingest):

   • Fastino detects shift toward later hours.

   • Updated summary:

The world model automatically adapts to reflect this new rhythm.

Example Implementation (Python)

import requests

BASE_URL = "https://api.fastino.ai"
HEADERS = {"Authorization": "x-api-key: sk_live_456", "Content-Type": "application/json"}

def get_routine_summary(user_id):
    r = requests.get(f"{BASE_URL}/summary?user_id={user_id}&purpose=routine", headers=HEADERS)
    return r.json()["summary"]

def query_next_action(user_id):
    q = {"user_id": user_id, "question": "What task should I suggest next based on routine?"}
    r = requests.post(f"{BASE_URL}/query", json=q, headers=HEADERS)
    return r.json()["answer"]

# Example usage
print(get_routine_summary("usr_42af7c"))
print(query_next_action("usr_42af7c"))

Integration in Agent Architectures

Combining with Other Use Cases

Use Cases

Best Practices

• Ingest timestamped events frequently for improved accuracy.

• Use purpose=routine for fast, deterministic summaries.

• Combine events from multiple tools for holistic temporal reasoning.

• Filter out system-generated events to reduce noise.

• Leverage correction signals (e.g., reschedules) to refine routine models.

• Avoid acting on routine predictions without confirming user boundaries.

Example: Deterministic Routine Summary

Response

{
  "summary": "Ash’s typical weekday routine: focus work 9–12 PT, meetings 1–4 PM, async responses after 6 PM. Avoid proactive actions early mornings or weekends."
}

This concise profile can guide any agent interacting with the user’s schedule or workflow.

Summary

The Routine Prediction use case allows agents to predict user behavior and adapt dynamically to their natural rhythms.
By learning daily and weekly cycles from event data, Fastino empowers assistants to schedule, remind, and respond at the right time — automatically.

Next, continue to Personalization Use Cases → Decision Prediction to explore how Fastino anticipates user choices based on context, preferences, and prior outcomes.