Decision Prediction

By analyzing historical decisions, patterns of reasoning, and contextual data, Fastino helps your assistants align proactively with user preferences — before they’re explicitly stated.

Overview

Every user has predictable decision heuristics: what they optimize for, how they weigh trade-offs, and when they defer.

Fastino’s Personalization API captures these patterns by analyzing ingested events, documents, and feedback — learning how users decide over time.

Agents can then query or retrieve decision summaries to:

• Anticipate preferences or selections.

• Recommend optimal choices.

• Avoid repeating undesired options.

• Explain reasoning in a user-consistent way.

Key Components

Example: Capturing Decision Data

Agents log decisions and results through the ingestion API to teach Fastino user preferences.

POST /ingest
{
  "user_id": "usr_42af7c",
  "source": "scheduler_agent",
  "events": [
    {
      "event_id": "evt_decision_1",
      "type": "decision",
      "timestamp": "2025-10-27T14:00:00Z",
      "metadata": {
        "decision_type": "meeting_reschedule",
        "option_chosen": "2 PM",
        "alternatives": ["10 AM", "2 PM"],
        "context": "Weekly sync"
      },
      "content": "User consistently chooses afternoon meetings when given a choice."
    }
  ]
}

Fastino incorporates this feedback to refine its decision embeddings and summaries.

Example: Querying User Decision Tendencies

POST /query
{
  "user_id": "usr_42af7c",
  "question": "How does Ash usually make scheduling decisions?"
}

Response

{
  "answer": "Ash prefers scheduling meetings after 1 PM and typically avoids early mornings. Decisions are pragmatic and consistent with established routines."
}

Agents can use this to automatically propose or filter options that align with these tendencies.

Example: Predicting Between Options

You can ask Fastino to simulate which option the user is likely to prefer in a trade-off scenario.

POST /query
{
  "user_id": "usr_42af7c",
  "question": "Would Ash prefer to prioritize speed or quality for this project?"
}

Response

{
  "answer": "Ash tends to prioritize speed and clarity over exhaustive quality checks, especially under time pressure."
}

This lets the agent choose defaults or suggestions with confidence while maintaining transparency.

Example: Decision Summary for Agents

Agents can retrieve deterministic summaries optimized for quick access:

Response

{
  "summary": "Ash makes fast, data-driven decisions. Prefers speed over perfection, values clarity, and adjusts priorities dynamically during high workload periods."
}

This summary can be injected into reasoning prompts or stored in memory for immediate contextual alignment.

Continuous Decision Learning

Fastino refines decision models using outcomes and feedback:

Agents can ingest all three types to build a feedback loop of decision refinement.

Example: Learning from Reversed Decisions

POST /ingest
{
  "user_id": "usr_42af7c",
  "source": "assistant",
  "events": [
    {
      "event_id": "evt_feedback_99",
      "type": "correction",
      "timestamp": "2025-10-27T17:00:00Z",
      "content": "User changed decision from 'auto-approve' to 'manual review' for outbound emails."
    }
  ]
}

Next time, Fastino will reflect this preference:

{
  "answer": "Ash now prefers manual review before sending external communications."
}

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_decision_summary(user_id):
    r = requests.get(f"{BASE_URL}/summary?user_id={user_id}&purpose=decision-style", headers=HEADERS)
    return r.json()["summary"]

def query_decision(user_id, question):
    payload = {"user_id": user_id, "question": question}
    r = requests.post(f"{BASE_URL}/query", json=payload, headers=HEADERS)
    return r.json()["answer"]

print(get_decision_summary("usr_42af7c"))
print(query_decision("usr_42af7c", "Does Ash prefer fast feedback or detailed reports?"))

Integration in Agent Systems

Combining with Other Use Cases

Use Cases

Best Practices

• Include both successful and corrected decisions for better balance.

• Use purpose=decision-style summaries in reasoning-heavy agents.

• Always communicate predicted reasoning back to the user for transparency.

• Regularly refresh summaries as user context evolves.

• Combine decision data with contextual metadata (source, type, timestamp) for richer embeddings.

• Avoid “locked” preferences — allow models to evolve with new feedback.

Example: Deterministic Decision Summary

Response

{
  "summary": "Ash makes pragmatic, speed-oriented decisions. Typically accepts proactive suggestions if low risk and reversible. Prefers concise justifications over detailed pros/cons lists."
}

This summary can be used as a reasoning condition in scheduling, planning, or strategy generation systems.

Summary

The Decision Prediction use case allows agents to understand how users make choices — not just what they choose.
By learning decision heuristics and contextual factors, Fastino enables decision-aware, proactive, and explainable AI behavior across every assistant or integration.

Next, continue to Personalization Use Cases → Personalized Retrieval to explore how Fastino retrieves and ranks the most relevant user data for grounding responses and reasoning.