Cross-tool reasoning

By connecting all user interactions through the Fastino Personalization API, your agents gain a unified understanding of the user’s context, goals, and activity — enabling them to coordinate across tools without losing continuity.

Overview

In multi-app ecosystems, agents often become siloed: one assistant handles scheduling, another manages messages, and a third tracks projects.

Fastino solves this by providing a single personalization layer that all agents can read from and write to.
This shared user model lets agents reason jointly, eliminating contradictions and fragmentation.

Key Capabilities

Example: Ingesting Multi-tool Data

Each connected tool can send structured events and documents to Fastino:

POST /ingest
{
  "user_id": "usr_42af7c",
  "source": "gmail",
  "events": [
    {
      "event_id": "evt_mail_01",
      "type": "email",
      "timestamp": "2025-10-27T09:00:00Z",
      "metadata": { "subject": "Follow-up with design team" },
      "content": "Let's schedule another sync next week to finalize assets."
    }
  ],
  "documents": [
    {
      "doc_id": "doc_notion_88",
      "kind": "note",
      "title": "Design sprint notes",
      "content": "Finalize hero section by Thursday. Ping design team in Slack."
    }
  ]
}

Once ingested, this data becomes part of a unified world model accessible across all tools.

Example: Unified Query Across Tools

Agents can retrieve context spanning multiple sources in one query:

POST /query
{
  "user_id": "usr_42af7c",
  "question": "What are Ash’s open design-related tasks and related email threads?"
}

Response

{
  "answer": "Ash has pending design tasks in Notion and a follow-up email with the design team scheduled for next week. A meeting invite is pending in Calendar."
}

This multi-source reasoning layer ensures cross-app consistency without duplicated logic.

Example: Coordinated Action

A calendar agent can reason about Slack and email data before acting:

POST /query
{
  "user_id": "usr_42af7c",
  "question": "Has the design team confirmed the Thursday sprint in Slack or email?"
}

Response

{
  "answer": "Yes. Confirmation received via Slack yesterday at 3 PM. No new updates in email."
}

The scheduling agent can now act confidently — or transparently ask for user confirmation if context is ambiguous.

Architecture

Cross-tool reasoning architecture:

All agents operate from the same adaptive user embedding, maintaining alignment across modalities and contexts.

Example: Cross-tool Memory Summary

Response

{
  "summary": "Ash’s ongoing work involves design sprints tracked in Notion, follow-ups coordinated via Gmail, and deadlines managed in Calendar. Prefers consolidated summaries across tools."
}

This deterministic summary ensures agents begin each session from a consistent state.

Example Implementation (Python)

import requests

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

def cross_tool_query(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"]

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

# Example usage
print(cross_tool_query("usr_42af7c", "What’s the latest status across Gmail and Notion?"))
print(cross_tool_summary("usr_42af7c"))

Multi-Agent Integration Pattern

Use Cases

Best Practices

• Always use a consistent user_id across all tool integrations.

• Include source metadata in each ingestion call for traceability.

• Use purpose=cross-tool summaries to initialize multi-agent sessions.

• Enable deduplication (options.dedupe:true) for redundant data from integrations.

• Pair with Action Boundaries & Transparency for safe, explainable cross-app actions.

• Use lightweight summaries instead of full data payloads for latency-sensitive use cases.

Example: Deterministic Cross-tool Summary

Response

{
  "summary": "Ash’s active projects are split between Notion and Gmail threads. The assistant should coordinate status updates without duplicating notifications."
}

This summary can be passed into downstream systems like LangChain or MCP to align multi-tool reasoning contexts.

Summary

The Cross-tool Reasoning use case allows agents to reason cohesively across multiple environments, powered by a single user world model.
By ingesting and retrieving context from all connected tools, Fastino transforms fragmented workflows into a unified cognitive layer — enabling seamless, context-aware collaboration across apps, agents, and sessions.

Next, continue to Personalization Use Cases → Personalized Retrieval to learn how to fetch user-specific snippets and embeddings for adaptive context grounding.