Skills are the hands of the Rixoffice agents. A model can reason about anything, but to actually read your document or build your deck it needs tools that understand the file format at a structural level. Rixoffice gives every app its own skill — a curated set of tools that match how that file type really works — so agents act on real structure instead of guessing at it. Understanding the skills tells you what the AI can and cannot do in each app.
The five skills
Each app maps to one skill, and the composer selects it automatically based on the file you have open:
| Skill | App | Size |
|---|---|---|
| docx | RixDocs | Document, table, chart and image tools |
| workbook | RixSheets | Range, cell, format and operations tools |
| slides | RixSlides | 35+ tools for decks and slide elements |
| PDF Editor | 20 tools for pages, text, markup and forms | |
| markdown | Markdown Studio | 4 core tools plus web_search |
How skills and agents combine
The agent roster and the skills are two halves of one system. Sisyphus, the orchestrator, picks the skill that matches your open file. Hephaestus executes through that skill's tools, block by block or range by range. Prometheus plans with the skill's read tools, Momus reviews with them, and Oracle stays read-only across all of them. Because every tool call goes through the same skill layer, agents behave identically whether you use built-in Rix AI, your own API key or a local Ollama model.
The docx skill
The docx skill works at the block level of a document, and its eleven tools cover the full round trip of reading, changing and enriching a file:- Understanding: get_document_context loads the document structure, read_blocks reads any part of it, search_blocks finds content by text or meaning, and read_attachment opens files you attached in chat.
- Editing: insert_content adds new blocks, replace_blocks rewrites existing ones, and apply_commands applies formatting and other commands to a target block.
- Enrichment: insert_image places pictures, insert_chart and edit_chart create and adjust charts, and web_search plus image_search bring in outside material without leaving the document.
Because edits target named blocks, a rewrite of one paragraph never disturbs the headings, tables or styles around it. That is the practical payoff of the block model described in the agents overview.
The workbook skill
The workbook skill respects how spreadsheets are actually used: inspect first, change second. Its tools are get_workbook_context, read_range, read_cells, read_formats, read_sheet_features, load_guide and propose_operations.
The order matters. The agent reads the workbook context, pulls the ranges and cells it needs, checks number formats and sheet features such as tables or merged cells, and consults the guide when a formula-dialect question comes up. Only then does it propose operations. Those proposals are what you review and accept — the AI chat in RixSheets is a negotiation, not a blind overwrite. The day-to-day flow is described in AI chat for workbooks.
The read-before-write discipline is what keeps spreadsheet AI safe: a proposal built on formats and merged-cell awareness is far less likely to break a model you spent weeks building.
The slides skill
The slides skill is the largest toolset in Rixoffice, with more than 35 tools. It spans the entire life of a presentation:
- Generation: generate_deck builds a full deck from a prompt, plan_deck produces the outline first, and execute_slide_script turns an HTML page script into real slide elements.
- Elements: add_smartart and add_chart create diagrams and data visuals, while crop_image and generate_image handle pictures, whether found on the web or generated to fit the layout.
- Research: web and image search are built in, so a deck about a market can cite and illustrate itself in one pass.
This skill drives the AI deck generation pipeline, which runs style selection, outline planning, image search, page scripts, placement, layout audit and a QC and fix loop before the deck reaches you. The size of the toolset is proportional to the job: a slide is a layout engine, not a text file.
The pdf skill
PDFs are a layout format, so the pdf skill ships 20 tools tuned to pages rather than paragraphs. It includes read_pages and search_text for understanding, markup_text and text and block editing for changes, generate_image for visual content, form fill for interactive documents, page operations such as rotate and delete, and outline tools for structure.
The result is that the agent can do in a PDF what the docx skill does in a document: find the right page, change exactly the target text or annotation, and leave the rest of the file untouched. That precision matters more in PDF than anywhere else, because a PDF is not meant to reflow. The app-side flow is described in PDF editor AI assistant.
The markdown skill
Markdown Studio stays minimal, and so does its skill: four core tools plus web_search. The small surface is deliberate — markdown files are plain text, so the agent drafts, refines and restructures blocks directly, and reaches for the web only when you ask for outside material. A lean toolset also means faster loops: fewer tool round trips per request, which you notice as snappier responses in long writing sessions. The writing-focused flow lives in Markdown AI panel.
One skill per file type is why the AI never asks you to explain your file format and never breaks it. The docx skill knows headings and tables, the workbook skill knows ranges and formats, the slides skill knows placeholders and layouts, and each hands the agents exactly the vocabulary of its format. When a new capability is added — a new chart type, a new page operation — it appears as a new tool in one skill, and every agent in the roster can use it immediately in the matching app.
What to explore next
- AI agents overview — the loop that drives these tools.
- Agent roster — who calls which skill, and when.
- AI web search — how the search tools work in every app.