Models that are yours, aligned with your values.
Most organisations rent generic AI that knows nothing about how they work and runs where someone else decides. Altilia gives you the whole stack to build personal AI instead: ontologies to curate your data, datasets built with synthetic data generation and human-guided data curation, small and large language models trained on them, reusable agents that populate those ontologies from even the most complex documents, and an operating system to deploy, govern and serve them for your most specific needs.
Aligned with your values
The ontology defines what a model can assert, your rules and policies bound what an agent can do, and human review sits exactly where your risk sits. Alignment is part of the architecture, versioned and auditable.
Accurate on your documents
A few-billion-parameter model trained on your ontology matches a frontier model on your task, faster and cheaper on every call. Accuracy is audited on your files, not on a public benchmark.
Owned, sovereign, portable
Ontologies, datasets, weights and agents are yours to keep, version and serve, on-premises or in your cloud, behind an OpenAI-compatible endpoint. No vendor lock-in, by construction.
From your knowledge to your model, in four steps.
Each step is a product you can use on its own; together they are the personal AI stack.
Curate
Describe what matters as an ontology: entities with a semantic description, extracted from text, images or both, nested into child ontologies for complex hierarchies. Ontologies are declarative, so domain experts build them without code, or let an agent draft one from a sample of documents. They are serialised and versioned, so every dataset stays traceable to the definition that produced it.
Train
Build the dataset with synthetic data generation under constrained decoding, so every example respects the ontology's grammar, and curate it with your experts. Train a few-billion-parameter model on it, or fine-tune a larger one. The trained model stays compatible with the ontology: swapping it in is a change of model-id.
Build
Compose agents in Python or YAML that reason, act and delegate to specialised sub-agents, with built-in tools for files, commands and web search. Agents populate the ontologies from your most complex data, hierarchical objects, tables, handwriting, multi-document files, and stream their work to your interfaces token by token.
Deploy
Models and agents run inside the Altilia OS on your infrastructure, under zero-trust governance with permissions and decision logs, exposed through OpenAI-compatible endpoints, APIs and MCP servers. They interoperate and federate with the AI platforms you already run, and serve the very specific needs of your organisation.
Two SDKs. One way of working.
Altilia Model Trainer turns documents into ontology-shaped datasets and trained models. The Altilia Agents SDK turns models into agents that do the work.
Structured extraction and model training SDK
- Native on text, images or both: a text span or a bounding box as output, matched to the input.
- Recursive, composable ontologies: entities with semantic descriptions and child ontologies for complex hierarchies.
- Constrained decoding with XGrammar: outputs that cannot violate the ontology's syntax.
- Typed few-shot examples sampled at runtime, so in-context learning always sees informative, well-formed cases.
- Automatic dataset generation from a frontier model, ready to train few-billion-parameter models.
- Multi-task in one step: entities, classification and generation from a single ontology.
- The same logic for interactive and batch extraction.
- Ontologies that are serialisable, versioned and buildable by non-technical users.
- OpenAI-compatible: works with any model behind an OpenAI-compatible endpoint, from any provider.
# Altilia Model Trainer: a recursive ontology, declarative, versioned description: Court-appointed technical appraisal (CTU) entities: - name: property_address description: Full address of the appraised property modality: text - name: cadastral_id description: Sheet, parcel and sub-unit as printed modality: text+image output: bbox - name: market_value description: Value estimated by the expert, in EUR modality: text children: - encumbrances: entities: [creditor, rank, amount, registration_date] decoding: constrained # XGrammar, output cannot break the schema
Agents and multi-agent systems
- Python framework built on LangGraph: a single agent or a system of collaborating agents, defined in code or in YAML.
- A reason-and-act loop: the model thinks, chooses a tool, executes it and repeats until it has an answer.
- Reasoning as a dedicated tool, natively when the model supports it (Gemini, GPT-5), or both together.
- Sub-agents that work autonomously and return their result to the main agent.
- Whole multi-agent systems orchestrated from YAML, with workspaces and sessions managed automatically.
- An event stream for chatbots and interfaces: generated tokens and tool actions in real time, sub-agents included.
- Automatic context compression of heavy tool outputs (files, JSON, logs) plus conversation summarisation, without an extra model.
- Hooks that attach logic to lifecycle moments without touching the agent's code.
- Ready-to-use tools: file management, command execution, web search.
- Works with any LangChain-compatible model, including Google Gemini and OpenAI.
# Altilia Agents SDK, LangGraph under the hood agent: npl_case_reviewer model: altilia/ctu-slm-3b # trained on court_appraisal v3 tools: [read_file, search_graph, run_command, web_search] sub_agents: - cadastral_reconciler - valuation_summariser context: compress_tool_outputs: true summarize_after_turns: 12 hooks: on_start: load_case_context after_run: write_decision_log events: stream # tokens + tool actions to the UI
Trained with an ethical methodology, on a pipeline you control.
Datasets are generated automatically and certified by human experts before a single weight changes. Training is a customisable pipeline of supervised fine-tuning, LoRA adaptation, preference optimisation and reinforcement learning from human feedback, run on your infrastructure and recorded in a model card.
Synthetic data
A frontier model, under constrained decoding, produces perfectly structured examples from your documents and ontology, at the scale your task needs.
Expert curation and certification
Your domain experts review the samples in the review workspace and certify two things: that the behaviour is correct, and that it complies with the ethical rules of your domain and your organisation.
SFT
Supervised fine-tuning teaches the model the format, the vocabulary and the decisions of your process from the certified dataset.
LoRA
Low-rank adapters specialise small and large models cheaply, one adapter per ontology or process, swappable without retraining the base.
DPO
Direct preference optimisation aligns the model with the choices your experts prefer, including refusals and escalations, using their certified judgements.
RLHF and evaluation
Reinforcement learning from human feedback closes the loop with corrections from production; every version is evaluated on your gold-standard set and released with a model card.
Behavioural correctness
Experts certify that the model produces the right output on gold-standard samples: the right entities, the right classification, the right abstention when the evidence is missing.
Ethical compliance
Experts certify that the samples respect the rules of the domain and of the organisation: non-discrimination, confidentiality, regulatory constraints, the values agreed in the alignment workshops.
Provenance and transparency
Every training pair is traceable to an ontology version and a source document; every model version ships with a model card describing data, method, evaluation and known limits.
What a personal model looks like: court appraisals for secured NPL.
An example from the catalogue, step by step.
- CurateAnalysts describe the appraisal as an ontology: property, cadastral identifiers, valuation, encumbrances, each with a semantic description and a modality (text or bounding box).
- TrainA frontier model reads a sample under constrained decoding; the structured input–output pairs, curated by the servicer's analysts, become the training set for a few-billion-parameter model dedicated to this ontology, served on the servicer's own infrastructure.
- BuildA case-review agent delegates to a cadastral reconciler and a valuation summariser, populates the knowledge graph and streams its reasoning to the reviewer's queue.
- DeployThe OS enforces who can run the agent and on which files, logs every decision with its source page, and exposes the model to the servicer's other systems.
Governable by a zero-trust approach. Open by design.
Every agent runs under least-privilege permissions and leaves a decision log. Every model, ontology and agent stays yours, and the OS federates with the AI platforms you already run.
No agent trusted by default
Each agent is identified, scoped to the data, tools and systems its process needs, and authorised on every call. Permissions, model versions and human review points are enforced by the OS, and every decision is logged with its sources for audit.
Standard interfaces in and out
Models are served behind OpenAI-compatible endpoints, agents work with any LangChain-compatible model, and connectors, REST APIs and MCP servers link the OS to CRM, ERP, ECM and core systems in both directions.
Runs alongside the platforms you have
The OS federates with hyperscaler, open-source and in-house AI platforms: route a task to their models, expose Altilia agents to their orchestrators, share the knowledge graph under your permissions. Ontologies, datasets, weights and agents remain your intellectual property and leave with you.