Agent OS​

La Console​

La nouvelle Console reunit en un seul ecran trois panneaux : configuration (modele, prompts, outils, MCP, acces), conversation en temps reel, et observation (trace du raisonnement, outils, tokens, journaux, historique). Vous construisez, lancez et diagnostiquez un agent sans jamais changer de page.

Le Graphe des agents​

Le Graphe des agents est une carte interactive de vos sessions : les executions au contenu proche sont rapprochees. Recherchez par description, cliquez sur un point pour explorer ses voisins similaires, filtrez par statut. Ideal pour retrouver des executions comparables ou reperer les cas atypiques.

Suivi du cycle de vie​

Le monitoring s'enrichit : au-dela du Hub (Kanban temps reel), un suivi du cycle de vie compare les versions, les evaluations, le cout et la latence pour decider quelle version promouvoir.

Connaissances​

Modes de recherche​

La recherche avancee propose desormais quatre modes selon votre intention — Lookup, Investigate, Latest, Authoritative — et une carte de transparence qui explique pourquoi chaque resultat remonte.

Graphe documentaire​

La vue Graphe gagne les territoires par proprietaire, les filtres de sante, la recherche de chemin entre deux documents, un mode investigation (facettes, tri, ensembles), les vues sauvegardees, le lien partageable et l'export PNG / SVG / JSON.

Pour aller plus loin​

• Vue d'ensemble d'Agent OS
• Base de connaissances

Ce qui change​

SDK TypeScript (@ontologie/sdk-client)​

Un client type-safe pour integrer Ontologie dans vos applications :

import { createClient } from '@ontologie/sdk-client';

const client = createClient({
  baseUrl: 'https://api.ontologie-growthsystemes.com',
  apiKey: process.env.ONTOLOGIE_API_KEY,
  workspaceId: 'votre-workspace-id',
});

// Requete avec filtres
const contracts = await client.ontology.query('Contract', {
  filter: { status: { eq: 'active' }, amount: { gt: 10000 } },
  orderBy: { field: 'amount', direction: 'desc' },
});

// Action gouvernee (dry-run → apply)
const plan = await client.actions.dryRun('Contract.approve', {
  targetId: contracts.data[0].id,
});
await client.actions.apply(plan.planId, {
  confirmed: true,
  riskAcknowledged: true,
});

Schema DSL (@ontologie/schema)​

Definissez votre modele metier en TypeScript :

import { objectType, string, number, enumType, action, compile } from '@ontologie/schema';

const Status = enumType('Status', ['draft', 'active', 'archived']);

const Contract = objectType('Contract', {
  title: string().required().indexed(),
  amount: number().required(),
  status: Status.default('draft').mutableBy(['Contract.approve']),
});

const Approve = action('Contract.approve')
  .when({ status: { eq: 'draft' } })
  .risk('medium')
  .roles(['manager']);

export default compile({ types: [Contract], actions: [Approve] });

CLI (@ontologie/cli)​

30+ commandes pour le workflow developpeur :

npx ontologie schema push          # Pousser le schema
npx ontologie schema diff          # Voir les differences
npx ontologie query Contract       # Requeter en CLI
npx ontologie actions dry-run Contract.approve --target $ID
npx ontologie actions apply --plan-id $PLAN_ID --confirm

Facturation DFU​

• Gratuit localement : prototypez avec le mock-server sans compte
• Prepaid en cloud : achetez des packs DFU (a partir de $30 / 200K DFU)
• Pas d'abonnement : payez uniquement ce que vous consommez
• Budget controls : plafonds mensuels, quotidiens et par commande

Securite​

Toute mutation passe par un plan signe : dry-run → inspection → apply. Chaque plan est :

• Signe cryptographiquement (HMAC)
• Lie a un actor specifique
• Expire selon le niveau de risque (1h / 24h / 7j)
• Verifie contre le schema actuel

Documentation​

La nouvelle section SDK & CLI couvre :

• Schema DSL — Declarer vos entites et actions
• Requetes — ObjectSet, filtres, graphe
• Plans et Actions — Cycle de vie des mutations
• Erreurs — Codes et remediations
• Facturation — DFU, quotas, budgets
• Cas d'usage — 6 scenarios metier detailles

Prochaines etapes​

• SDK TypeScript — Commencer
• Facturation — Comprendre les DFU
• Quickstart — Premier appel en 10 minutes

Data Model​

View the page

Understand the fundamental building blocks: entity types, properties, relations, and instances. A simplified diagram illustrates the difference between a type and an instance.

Workspaces and Spaces​

View the page

Two levels of organization: the workspace (isolated tenant) and the space (a canvas within a workspace). Members, roles, and data isolation.

Advanced Search​

View the page

Semantic vs. lexical search, hybrid search, filters by source and document type, automatic weighting, and practical examples.

Recurring Events​

View the page

New page on recurrence: recurrence types, editing and deleting individual occurrences, concrete examples, and limitations.

Set Up Team Governance​

View the tutorial

Configure your team's roles, create approval policies, classify your entities, and test the full validation flow.

Modules: Governance + Settings + Ontologie

Simulate the Impact of a Change​

View the tutorial

Create a simulation scenario, add virtual mutations, calculate the impact on your ontology, and decide whether to apply or discard the changes.

Modules: Simulation + Ontologie + Dashboard

Keyboard Shortcuts​

View the page

All keyboard shortcuts documented: quick navigation between modules (Ctrl+1 through Ctrl+3), editing (Ctrl+Z, Ctrl+S, Ctrl+D), and the command palette (Ctrl+K).

Command Palette​

View the page

Reach any page, entity, or action in just a few keystrokes with Ctrl+K. Federated search across pages, entity types, instances, workflows, and views.

FAQ​

View the FAQ

Answers to the most frequently asked questions, organized by topic: account and access, ontology, Live Data, Agent Studio, and API.

Connect Data and Analyze It with AI​

View the tutorial

Connect an external source (Google Sheets, API, etc.), link the data to your ontology, and query everything with an AI agent.

Modules: Live Data + Ontologie + Agent Studio + Dashboard

Automate a Business Process​

View the tutorial

Create a workflow that reacts to an ontology event, calls an AI agent to analyze the situation, and sends an email notification.

Modules: Ontologie + Workflow Builder + Agent Studio + Email

Build an Agent Powered by Your Documents​

View the tutorial

Import documents into the knowledge base and create a specialized agent that answers questions by citing its sources.

Modules: Knowledge Base + Agent Studio

Module Architecture​

A new Module Architecture page explains how modules interconnect, with a visual diagram of the data flows.

5 Steps to Get Started​

The walkthrough guides you through:

1. Create a workspace — Your dedicated work environment
2. Model an entity — Your first entity in the Modeler
3. Connect a source — Sync external data
4. Query the AI agent — Ask questions about your data
5. Create a workflow — Automate an action

Settings and Configuration​

Three new settings pages accompany this guide:

• Account Settings — Profile, security (2FA), appearance, notifications
• Workspace Management — Members, roles, spaces
• AI Models — Connect your own LLM providers (BYO-key)

The existing guide has been renamed Quick Start (API) and remains available for programmatic integrations.

Spreadsheets — 7 New Pages​

The Spreadsheets section grows from 1 to 8 pages and now covers:

• Editing data — Cell editing, keyboard shortcuts, adding and removing rows and columns
• Column types — Reference for the 15 available types (text, number, date, select, entity...)
• Import and export — CSV/Excel import with a mapping wizard, export with filters
• Filters and views — Filter engine, multi-column sorting, grouping, saved views, and Kanban view
• Forms — Form builder with configurable fields, public forms
• Natural language queries — Query your spreadsheets in natural language using AI
• Ontology linking — Link your rows to entities in your business model

Dashboard — 4 New Pages​

The Dashboard section grows from 1 to 5 pages:

• Timeline and events — Chronological feed filtered by module, time period, and keyword
• KPI indicators — Metrics reference by module (Ontologie, Workflows, API, Agent Hub)
• Quick actions — Common operations accessible without switching modules
• Diagnostics and health — Incident panel, latency histogram, log explorer

Why Agent Studio v2​

Agent Studio v1 allowed you to create, configure, and test AI agents. But in production, several needs emerge:

• Understanding: when an agent gives an unexpected answer, why? Which step in its reasoning went wrong?
• Engine choice: different use cases require different models and frameworks. A triage agent doesn't have the same needs as a data analysis agent.
• Production tracking: how many executions, what success rate, what cost per request, which tools are used most?

Version 2 addresses all three of these needs with visual tools and actionable metrics.

What's New​

Real-Time OODA Visualizer​

At the core of Agent Studio v2 is the OODA visualizer. It displays your agent's reasoning steps in real time following the OODA loop (Observe, Orient, Decide, Act):

What you see:

• The reasoning flow: each step is represented visually on an interactive canvas. You follow the path the agent took from the initial query to the final response.
• Tools used: which tools the agent chose to use, with what parameters, and what results they returned.
• Decisions: at each branching point, you see why the agent chose one path over another.
• Timing: how long each step took, and where the bottlenecks are.
• Feedback loops: when the agent re-evaluates its results and decides to retry or refine its response.

Real-time updates: while an agent is running, the visualizer updates live. You see each node activate, each decision being made, each tool executing — like a visual debugger for AI.

Practical example: a user asks "Which clients don't have an active contract?" and the agent responds with an incomplete list. By opening the visualizer, you see that the agent used a keyword search instead of a structured query, which missed clients whose names didn't contain the word "client." You adjust the search tool configuration and the problem is resolved.

Multi-Framework Support​

Agent Studio v2 supports multiple AI frameworks so you can choose the best fit for each use case:

How it works:

• Framework selection: when creating an agent, select the appropriate framework in the editor.

• Framework-specific configuration: each framework has its own parameters (Ax signatures, routing strategies, etc.).
• Same interface: regardless of the framework, Agent Studio provides the same creation, testing, and monitoring experience.
• Easy migration: switch frameworks without reconfiguring your tools and integrations.

Practical example: for a ticket classification agent, you use Ax (fast, low cost). For a complex data analysis agent, you switch to the native agent with the full OODA loop. Both agents are created and managed in the same interface.

Advanced Monitoring​

The monitoring Hub provides a comprehensive view of your agents' activity in production:

Kanban dashboard: visualize running, successful, and failed executions in a real-time kanban view.

Detailed metrics:

• Volume: number of executions per hour, day, and week.
• Success rate: percentage of requests processed successfully.
• Latency: average response time, p50, p95, p99.
• Tools: which tools are used most, which ones fail most often.

Execution history: for each execution, review the full detail: query, response, tools used, duration of each step, and any errors.

Filters and search: filter by date, status, agent, or search by query content.

Practical example: you notice that the success rate of your "Sales Assistant" agent has dropped from 95% to 82% this week. By reviewing the failed executions, you identify that an external endpoint changed its response format. You update the affected tool's configuration and the rate recovers.

Enriched Template Gallery​

The template gallery has been expanded to make agent creation easier:

• Use-case templates: FAQ assistant, data analyst, triage agent, reporting agent.
• Industry templates: e-commerce, finance, human resources, logistics.
• Guided customization: each template includes explanations of which parameters to adjust.

Improved Navigation​

Navigation in Agent Studio has been redesigned for quick access:

• Dedicated sidebar: direct access to the gallery, monitoring, and visualizer.
• Smooth transitions: switch from the monitoring Hub to the visualizer in a single click.

Getting Started​

1. Navigate to Agent Studio in the main menu.
2. Create an agent from the gallery: choose a template or start from scratch.
3. Configure tools: select the tools your agent can use.

4. Test in the editor with sample queries.

5. Publish and track performance in the monitoring Hub.
6. Debug with the OODA visualizer when behavior is unexpected.

Next Steps​

• Agent Studio — Agent Studio overview
• Create an agent — Step-by-step creation guide
• Monitoring — Understanding the monitoring Hub
• OODA Visualizer — Visualizer guide
• Support — Need help with your agents?

Why a Client Portal​

Until now, integrating Ontologie into your applications required you to:

• Read the API reference (hundreds of endpoints) to find the right calls.
• Manually write HTTP calls with the correct headers, body, and parameters.
• Test against your production workspace, risking changes to real data.
• Handle authentication, pagination, errors, and types without any assistance.

The Client Portal eliminates these friction points by providing everything a developer needs in one place.

What's New​

Interactive Documentation​

The Client Portal offers interactive documentation where each endpoint comes with:

• Clear description: what the endpoint does, when to use it, and which permissions are required.
• Documented parameters: each parameter is described with its type, possible values, and examples.
• Code examples: copy-paste-ready snippets in TypeScript, Python, curl, and other languages.
• Built-in tester: execute an API call directly from the documentation and see the response in real time.
• Response schemas: the exact response format, with the type of each field.

Practical example: you want to list the entities in your ontology. The Client Portal shows you the GET /reference/api/queries/nodes endpoint, its filtering and pagination parameters, a sample request in TypeScript, and lets you execute it with your API key to see real data from your workspace.

TypeScript SDK​

The TypeScript SDK lets you interact with Ontologie from any Node.js, Deno, or browser application:

import { DataForgeClient } from '@dataforge/client';

const client = new DataForgeClient({
  apiKey: 'ont_live_votre_cle_api',
  workspaceId: 'votre-workspace-id',
});

// List entities
const entities = await client.nodes.list({
  entityType: 'concept',
  limit: 10,
});

// Create an entity
const newEntity = await client.commands.execute({
  type: 'CREATE_NODE',
  payload: {
    name: 'Mon entite',
    entityType: 'concept',
    position: { x: 100, y: 200 },
  },
});

SDK features:

• Full typing: autocompletion and compile-time validation through generated TypeScript types.
• Error handling: API errors are typed and structured (code, message, details).
• Automatic pagination: iterate over large collections without managing cursors manually.
• Built-in retry: transient errors (429, 503) are automatically retried.
• Streaming: native SSE support for long-running operations (agent invocation, workflow execution).

Python SDK​

For data teams and Jupyter notebooks, the Python SDK offers the same experience:

from dataforge import DataForgeClient

client = DataForgeClient(
    api_key="ont_live_votre_cle_api",
    workspace_id="votre-workspace-id",
)

# List entities
entities = client.nodes.list(entity_type="concept", limit=10)

# Semantic search
results = client.search.semantic("clients avec contrat expire")

The Python SDK is compatible with pandas, Jupyter, and data science pipeline environments.

Sandbox​

The sandbox is an isolated test environment where you can experiment risk-free:

• Test data: the sandbox comes pre-populated with sample data representing a typical ontology.
• Sandbox API key: a dedicated API key is automatically generated for the sandbox.
• Reset on demand: restore the sandbox to its initial state at any time.
• Same APIs: the endpoints and behavior are identical to production — only the data differs.

Practical example: you're developing an integration that modifies entities. Instead of testing against your production workspace, you use the sandbox to validate your code. Once satisfied, you switch the API key to point to production.

OAuth Packages​

For applications that authenticate on behalf of a user (rather than with an API key), the SDK includes an OAuth package:

• Standard OAuth2 flow with PKCE.
• Automatic token refresh.
• Compatible with popular web frameworks (React, Next.js, Express).

React Package​

A React package is also available for frontend applications:

import { useNodes, useCommands } from '@ontologie/react';

function EntityList() {
  const { data: nodes, isLoading } = useNodes({ entityType: 'concept' });
  const { execute } = useCommands();

  const handleCreate = async () => {
    await execute({
      type: 'CREATE_NODE',
      payload: { name: 'Nouvelle entite', entityType: 'concept' },
    });
  };

  if (isLoading) return <p>Loading...</p>;
  return (
    <ul>
      {nodes.map((node) => (
        <li key={node.id}>{node.name}</li>
      ))}
    </ul>
  );
}

The React hooks automatically handle caching, revalidation, and optimistic updates.

Getting Started​

1. Access the Client Portal via the link in the navigation bar ("Client Portal") or at portal.ontologie-growthsystemes.com.
2. Explore the interactive documentation: browse endpoints by category.
3. Test in the sandbox: use the built-in tester to execute API calls.
4. Install the SDK:
   • TypeScript: npm install @dataforge/client
   • Python: pip install dataforge
5. Integrate into your application using your API key.

Next Steps​

• API Reference — Complete endpoint documentation
• API Keys — Create and manage your access keys
• Quickstart — First API call in 10 minutes
• Support — Need help integrating Ontologie?

Why Workflow Automation​

A workflow that runs manually is fine for testing. But in production, you need your workflows to:

• Run automatically at regular intervals (every day at 8 AM, every Monday, the 1st of each month).
• Recover on their own from transient errors (network timeouts, temporarily unavailable services).
• Notify you when a problem requires human intervention.
• Be duplicable so you can create variants without starting from scratch.

This is exactly what this update brings to the Workflow Builder.

What's New​

Cron Scheduling​

Schedule automatic execution of your workflows using standard cron expressions:

• Cron expressions: the full power of cron syntax (0 8 * * 1-5 = every weekday at 8 AM).
• Visual editor: a visual editor translates the cron expression into plain language ("Every weekday at 08:00").
• Time zones: configure the time zone for your schedule (Europe/Paris by default).
• Overlap protection: if an execution is still running when the next one is scheduled, it is queued instead of starting in parallel.

Common schedule examples:

Practical example: you create a "Weekly Data Quality Report" workflow and schedule it every Monday at 9 AM. The workflow runs automatically, generates the report, and sends an email to the team.

Automatic Retry and Resume​

Workflows in production inevitably encounter errors: an external service is temporarily unavailable, a network timeout, an exceeded API quota. Instead of failing permanently, workflows can now recover automatically.

Retry:

• Configure the number of attempts (1 to 5) and the delay between each attempt.
• The delay can be fixed (30 seconds) or exponential (30s, 60s, 120s, 240s).
• Each attempt is logged in the execution history.

Resume:

• If a workflow fails after all retry attempts, it pauses at the point of failure.
• You can fix the issue (e.g., renew an API token) and resume execution right where it left off.
• No need to re-run the steps that already completed — the workflow resumes exactly at the block that failed.

Practical example: your data import workflow fails due to a timeout on an external API. The system retries 3 times with exponential backoff. If the API is still unavailable, the workflow pauses. An hour later, the API is back — you click "Resume" and the workflow continues where it left off.

Workflow Cloning​

Duplicate an existing workflow in a single click:

• Full copy: all blocks, connections, configurations, and variables are duplicated.
• Automatic renaming: the clone is named "My workflow (copy)" — rename it as needed.
• Independence: the clone is completely independent from the original. Changes to one do not affect the other.
• Use cases: create variants (test vs. production), duplicate for another workspace, back up before modifying.

Practical example: you have an "Import Clients France" workflow that works well. You clone it and modify the clone to create "Import Clients Belgium" by changing only the filtering parameters.

Alerts​

Get notified when a workflow needs your attention:

• Execution failure: receive an alert when a workflow fails (after all retry attempts).
• Long-running execution: receive an alert when a workflow exceeds a configurable duration.
• Notification channels: email, webhook, or in-app notification.
• Filtering rules: configure which workflows trigger alerts and who receives them.

Practical example: you set up an alert on your "Daily Sync" workflow: if the execution fails or exceeds 10 minutes, an email is sent to the operations team.

In-Flight Cancellation​

New control over running workflows:

• Clean cancellation: stop a running workflow without corrupting data.
• "Cancelled" state: the workflow is marked as cancelled in the history, distinct from a failure.
• Cleanup: allocated resources (temporary files, connections) are released cleanly.

Getting Started​

1. Open the Workflow Builder and select an existing workflow.
2. Configure the schedule in the "Scheduling" tab: choose a cron expression or use the visual editor.
3. Configure retry in the advanced settings of each sensitive block.
4. Enable alerts in the "Alerts" tab of the workflow.
5. Test by running the workflow manually, then let the schedule take over.

Scheduling is available for all workflows. Alerts are configured per workflow in the advanced settings.

Next Steps​

• Workflow Builder — Workflow Builder overview
• Available blocks — List of 21+ block types
• Scheduling — Complete cron scheduling guide
• Run and debug — Execution tracking and history
• Support — Need help automating your workflows?

Why MCP​

The Model Context Protocol (MCP) is an open standard that allows AI assistants to interact with external data sources in a structured and secure way. Instead of copying and pasting data between your ontology and your AI assistant, MCP creates a direct bridge.

The use cases are numerous:

• Data exploration: ask Claude "What are the Customer entities that have no relation to a Contract?" and get a real-time answer from your ontology.
• Assisted editing: "Add a 'last_review_date' property to all Process entities" — the assistant executes the command via MCP.
• Analysis and reporting: "Summarize the status of my data validation workflow" — the assistant retrieves execution statuses and provides a synthesis.
• Development: in VS Code or Cursor, query your ontology while you code to generate code that is consistent with your data model.

What's new​

159 tools across 13 categories​

The Ontologie MCP server exposes 159 tools organized into 13 categories covering the entire platform:

Each tool is documented with its input schema, output schema, and usage examples.

Connecting to Claude Desktop​

To connect Claude Desktop to your Ontologie workspace:

1. Generate an MCP API key in Settings > API Keys with the mcp.read and mcp.write scopes.
2. Configure Claude Desktop by adding the MCP server in the settings:

{
  "mcpServers": {
    "ontologie": {
      "url": "https://api.ontologie-growthsystemes.com/mcp",
      "headers": {
        "Authorization": "Bearer ont_live_votre_cle_api",
        "x-workspace-id": "votre-workspace-id"
      }
    }
  }
}

3. Test it by asking Claude a question: "List the 10 most recently created entities in my ontology."

Claude will automatically have access to all 159 tools and will use them based on your questions.

Connecting to VS Code and Cursor​

MCP-compatible code editors (VS Code with the Claude extension, Cursor) are configured the same way:

1. Add the server in your editor's MCP configuration.
2. Use the tools in the assistant chat: "Show me the schema of the 'Order' entity in my ontology."
3. Generate code that is consistent with your data model: "Generate a React component that displays the properties of a Customer based on my schema."

Security and permissions​

The MCP server respects the Ontologie permission system:

• API scopes: the available tools depend on your API key's scopes (mcp.read, mcp.write, mcp.workflow.execute, mcp.agent.execute).
• Workspace isolation: each connection is isolated within its workspace. No data can be accessed outside the API key's workspace.
• Audit: all actions performed via MCP are logged in the audit trail.
• SSE streaming: long-running operations (workflow execution, agent invocation) use streaming for real-time feedback.

Resources and Prompts​

In addition to tools, the MCP server exposes:

• 7 Resources: direct access to structured data (ontology schema, workflow list, etc.) that AI clients can consult.
• 7 Prompts: pre-configured query templates for common use cases (ontology exploration, workflow analysis, etc.).

Getting started​

1. Create an MCP API key in Settings > API Keys.
2. Select the scopes: mcp.read for read access, mcp.write for modifications.
3. Copy the configuration provided on the API key page.
4. Paste it into your MCP client (Claude Desktop, VS Code, Cursor).
5. Test it with a simple request: "How many entities does my ontology contain?"

Next steps​

• MCP Server — MCP server overview
• Configuration — Connection and configuration guide
• Available tools — Full list of all 159 tools
• API Keys — Manage your keys and scopes
• Support — Need help setting up MCP?

Why a built-in calendar​

Until now, planning tasks related to your ontologies was done in external tools (Google Calendar, Outlook, spreadsheets). This fragmentation created several problems:

• No link to your data: events in your external calendar are not connected to your entities.
• No business recurrence: generic calendars do not handle the recurrence rules specific to your processes.
• No unified view: to see what is planned, you have to juggle multiple tools.
• No automation: there is no way to trigger a workflow when an event occurs.

The Calendar module brings scheduling directly into Ontologie with bidirectional links to your data.

What's new​

Event management​

Create, edit, and organize your events directly within your workspace:

• Calendar view: day, week, month — with filters by type, linked entity, or calendar.
• Multiple calendars: create several calendars per workspace (e.g., "Project milestones", "Maintenance", "Team meetings").
• Linked events: associate an event with one or more entities in your ontology. The event appears in the entity's detail view and in the calendar.
• Reminders: set up email or notification reminders before each event.

Practical example: you create a "Quarterly data model review" event linked to your "Main Ontology" entity. All workspace members see the event in the calendar and can navigate directly to the relevant entity.

Advanced recurrence​

The Calendar module supports full recurrence following the RFC 5545 standard (the same one used by iCal and Google Calendar):

• Frequencies: daily, weekly, monthly, yearly.
• Advanced rules: "every 2nd Tuesday of the month", "every last business day", "every 2 weeks excluding holidays".
• Exceptions: remove or reschedule individual occurrences without breaking the series.
• End date: number of occurrences or a cutoff date.

Occurrences are generated dynamically — you do not need to manually create each event.

Practical example: you schedule a "Data quality review" on the first Monday of every month for a year, with an exception for August (vacation). The calendar automatically displays the 11 occurrences.

Google Calendar and Outlook sync​

Connect your Ontologie calendar to your external calendars for a unified view:

• Import: events from your Google Calendar or Outlook appear in the Ontologie calendar.
• Export: events created in Ontologie are synced to your external calendar.
• Bidirectional: changes are propagated in both directions.
• OAuth2 authentication: secure connection with no password sharing.

Synchronization happens in real time. Imported events are visually distinguished from native events.

Practical example: your team uses Google Calendar daily. By enabling sync, your Ontologie project milestones automatically appear in each member's Google Calendar, with a direct link to the relevant entity.

Integration with Workflows and Agents​

The calendar is not just a scheduling tool — it integrates with the rest of the platform:

• Workflow blocks: 4 new blocks in the Workflow Builder to create, modify, list, and delete events.
• Agent tools: AI agents can query the calendar, create events, and send reminders.
• Triggers: trigger a workflow when an event approaches or when a new occurrence is generated.

Practical example: a "Compliance reminder" workflow triggers automatically 7 days before each regulatory review deadline, sends an email to the team, and creates a task in the workspace.

Getting started​

1. Navigate to Calendar in the main menu of your workspace.
2. Create a calendar (e.g., "Project milestones") or use the default calendar.
3. Add an event by clicking on a date or using the "New event" button.
4. Set up recurrence if the event repeats.
5. Link the event to entities via the "Linked entities" field in the form.
6. Enable sync in Settings > Integrations > Google Calendar or Outlook.

The calendar is accessible to all workspace members. Configuring sync requires administrator access.

Next steps​

• Calendar — Calendar module overview
• Create an event — Create and manage events
• Edit an event — Edit, move, and delete events
• Sync — Connect Google Calendar or Outlook
• Support — Need help setting up the calendar?

Why simulation matters​

Ontologies model the current state of your systems, processes, and data. But business decisions often require answering questions like:

• What happens if I remove this supplier? Which processes are affected?
• What is the best allocation of resources to minimize costs?
• How will the workload evolve if I add 3 clients per month for a year?

Until now, these analyses were done in separate spreadsheets, disconnected from your data model. The Simulation module brings these capabilities directly into Ontologie.

What's new​

Parametric scenarios​

A scenario is an isolated copy of all or part of your ontology in which you can freely modify data without affecting production.

How it works:

1. Create a scenario from your current ontology or from a selection of entities.
2. Modify the data: add, delete, or update entities and relations.
3. Compare: view the differences between the scenario and production (additions, deletions, modifications).
4. Analyze the impact: the system automatically calculates which entities, relations, and workflows are affected by your changes.
5. Apply or discard: if the scenario proves successful, merge the changes into production. Otherwise, delete it with no consequences.

Scenarios use a copy-on-write technique: only the modified data is duplicated, making scenario creation fast and storage-efficient.

Practical example: you are considering reorganizing your ontology by merging two entity types ("Prospect" and "Lead") into one ("Contact"). You create a scenario, perform the merge, and the impact analysis shows that 3 workflows and 2 dashboards referencing "Prospect" will need to be updated.

Optimization solvers​

Solvers let you define optimization problems on your data and obtain automatically computed solutions.

A solver is defined by:

• Variables: the elements the solver can change (e.g., resource assignments, quantities).
• Constraints: the rules that must be respected (e.g., maximum budget, limited capacity, deadlines).
• An objective: what you want to minimize or maximize (e.g., total cost, processing time, coverage).

The solver explores possible combinations and returns the optimal solution or the best solutions found.

Practical example: you have 15 projects to assign to 5 teams, each with limited capacity and specific skill sets. The solver calculates the assignment that minimizes total completion time while respecting the skill constraints.

Temporal simulations​

Temporal simulations let you project how your data will evolve in the future based on rules you define.

You configure:

• A time horizon: how many days, weeks, or months to simulate.
• A time step: the granularity of the simulation (day, week, month).
• Evolution rules: how the data changes at each step (e.g., +3 clients/month, -5% attrition, data volume doubling every 6 months).

The simulation generates a time series of your ontology's state at each time step. You can visualize trends, identify tipping points, and adjust your rules.

Practical example: you simulate the growth of your customer base over 12 months with an acquisition rate of 50 clients/month and an attrition rate of 8%. The simulation shows that by month 9, the number of support tickets will exceed your current team's capacity.

Getting started​

1. Open your workspace and navigate to Simulation in the main menu.
2. Create a scenario by clicking "New scenario" and selecting the entities to include.
3. Modify the data within the scenario and review the impact analysis.
4. For solvers: define your variables, constraints, and objective in the solver editor.
5. For temporal simulations: configure the time horizon, time step, and evolution rules.

Scenarios are accessible to all workspace members. Solvers and temporal simulations require administrator access for configuration.

Next steps​

• Scenarios — Complete guide to parametric scenarios
• Solvers — Configure and run solvers
• Temporal simulations — Project how your data evolves
• Governance — Combine simulation and governance for informed decisions
• Support — Need help setting up simulation?

Why data governance matters​

In a collaborative ontology project, several situations become problematic without governance:

• A team member modifies a critical entity without prior review.
• Sensitive data (personal information, financial records) is not identified as such.
• There is no way to know where a piece of data came from or what transformations it went through.
• Data entry errors and inconsistencies accumulate undetected.

The Governance module addresses these four needs with features built directly into your workspace.

What's new​

Multi-level approvals​

Approvals let you define validation workflows before certain changes take effect. You can configure:

• Who must approve: one or more team members, by role or by name.
• Which actions trigger an approval: creating, modifying, or deleting entities, relations, or properties.
• How many approvals are required: single sign-off or multi-level consensus.

When an action subject to approval is triggered, it is placed on hold. The approver receives a notification and can accept or reject the change with a comment. The full decision history is retained.

Practical example: you define that any modification to a "Contract" entity requires approval from the legal lead. A team member renames a contract — the change remains pending until it is validated.

Data classifications​

Classifications let you label your entities and properties according to their sensitivity level. Four levels are available by default:

Classifications are visible directly on entities in the Modeler. They serve as the foundation for access policies and compliance reports.

Practical example: you classify all properties containing email addresses as "Confidential." A governance report then lists every entity containing confidential data and verifies that access is properly restricted.

Lineage (data traceability)​

Lineage answers one question: where does this data come from, and where does it go?

For each entity or property, you can view:

• The origin: which data source, connector, or manual entry created the data.
• Transformations: which workflows or agents modified the data.
• Downstream dependencies: which dashboards, reports, or workflows consume the data.

Lineage is built automatically from events in your workspace. Every modification, every workflow execution, every Live Data ingestion enriches the traceability graph.

Practical example: a KPI on your dashboard shows an unexpected value. By consulting the lineage of the source data, you discover that a workflow changed the calculation formula the previous week.

Data quality rules​

Quality rules let you define constraints on your data and automatically detect anomalies:

• Completeness: verify that required fields are filled in.
• Uniqueness: detect duplicates on a field or combination of fields.
• Format: validate data formats (email, phone number, postal code, etc.).
• Consistency: verify relationships between entities (e.g., a "Contract" must be linked to a "Customer").

Results are displayed in a dedicated dashboard with an overall quality score and per-rule indicators. Entities with errors are flagged directly in the Modeler.

Practical example: you create a rule "Every customer must have a valid email." The system analyzes your entities and flags the 12 customers whose email field is empty or malformed.

Getting started​

1. Open your workspace and navigate to Settings > Governance.
2. Enable the modules you need (approvals, classifications, quality).
3. Create your first rule — either an approval rule or a quality rule.
4. Classify your sensitive entities via the properties panel in the Modeler.
5. View the lineage of an entity by clicking the "Lineage" tab in its detail view.

Governance features are available to workspace administrators. Approvers are configured by administrators.

Next steps​

• Approvals — Complete guide to approval workflows
• Classifications — Configure sensitivity levels
• Lineage — Understand data traceability
• Quality — Define and track your quality rules
• Support — Need help setting up governance?

• A public end-user documentation structured by blocks (Ontology, Live Data, Knowledge base, Agents, Workflows, API).
• An initial English version is available via the language dropdown.

Who is it for​

• All end users.

Where to find it​

• FR: docs homepage.
• EN: select English in the language dropdown.

Need help?​

Write to us: Support and contact.