univer.ai

Univer is an office harness for AI agents: a single runtime that handles spreadsheets, documents, slides, canvases, relational tables, and PDFs, and turns office files into structured, verifiable code. It fits you if you're building a product that needs multiple office tools working on the same data, or if you want agents to edit real office files with human review rather than one-shot generation. It is not a standalone office app you download — the site positions it as an SDK plus a runtime you embed and self-host.

The core idea: one runtime, six tools

Most office stacks are separate applications that happen to share a file format. Univer inverts that: six tools share the same storage and computation layer, so they can compose and embed freely.

The practical consequence: a slide can hold a live sheet, a doc can cite its source, and a canvas can lay it all out — with references updating when sources change. That's the difference between "export a chart image into a deck" and "the deck reads the sheet."

Why "agent-native" matters

The site's framing is that every file becomes structured, verifiable code. Three mechanisms back that up:

• Isolated worktrees. Multi-agent workflows run on worktrees, parallel by default. Agents don't fight over one mutable file.
• Human-reviewed changes. Changes are reviewed by design, not as an afterthought — you can trace every edit.
• Shared context across file types. Agents work across every file type without losing context, because the tools share one runtime rather than passing files between apps.

The site lists compatibility with OpenCode, Claude Code, OpenClaw, Hermes, Codex, WorkBuddy, and Kimi Work, so the harness is meant to sit under whichever agent you already use.

What you actually build with

Univer ships as an Office SDK. According to the site, you can:

• Build with all six office tools and multi-agent worktrees inside your own product
• Build your own UI and UX on top of the SDK
• Self-host and connect your own auth, databases, and knowledge bases
• Customize formulas, assets, and components down to the engine
• Use one integration for all six tools, composed and embedded freely

There's a copyable SDK prompt and a live demo linked from the page if you want to evaluate before committing.

When Univer is the right choice

Choose it when your product needs more than one office surface sharing the same data, when agents must edit files with reviewable diffs, or when you need to self-host and wire in your own auth and storage. Look elsewhere if you want a finished end-user office suite, or if a single embedded spreadsheet is all you need — the six-tool runtime is the point, and you'd be paying for scope you don't use.

The site's own summary is the cleanest test: "Not one tool — the whole runtime." If that sentence describes your requirement, start with the SDK prompt and the live demo.

Univer is an office runtime built for AI agents: spreadsheets, docs, slides, canvases, relational tables, and PDFs share one storage and computation layer, and every file becomes structured, verifiable code that agents can read and change. That matters if you want agents to work across mixed office files without losing context, and if you need human review of every change. It is not a single-purpose spreadsheet library, and it is not a hosted product you simply log into — the site positions it as an SDK you embed, self-host, and connect to your own auth, databases, and knowledge bases.

What “agent-native” changes in practice

In a conventional office suite, a file is a document for humans and an opaque blob for software. An agent can open it, but it cannot reliably reason about its structure, and it cannot verify what it changed.

Univer inverts that. The runtime treats office content as structured, verifiable code. The practical consequences:

• Agents work across every file type without losing context. Sheets, docs, slides, canvases, relational tables, and PDFs run on the same runtime, so an agent moving from a table to a slide that cites it does not restart from zero.
• Data stays synchronized. When a source changes, references update. A slide can hold a live sheet; a doc can cite its source; a canvas can lay out the result.
• Humans and agents co-edit the same file. Every change is traceable, and the design assumes human-reviewed changes rather than unreviewed automation.

One runtime, six tools

The composition model is the part that distinguishes Univer from stitching together separate libraries.

Because sheets, docs, slides, and canvases live in one .univer file, they compose and embed freely. A slide holding a live sheet is not an import — it is the same object, so the reference stays current.

Multi-agent workflows on worktrees

Parallel agent work usually fails at merge time. Univer's answer is isolated worktrees: agents work in parallel by default, and their changes are human-reviewed by design. You get concurrency without giving up a review gate.

The runtime is built for any agent — the site lists OpenCode, Claude Code, OpenClaw, Hermes, Codex, WorkBuddy, and Kimi Work — so the workflow layer is not tied to one vendor.

How you would actually adopt it

Univer is an SDK, so the path is build-and-embed rather than sign-up-and-use:

1. Start from the SDK. Build with all six office tools and multi-agent worktrees inside your own product.
2. Build your own UI and UX. The SDK does not dictate the interface.
3. Self-host. Connect your own auth, databases, and knowledge bases.
4. Customize down to the engine. Formulas, assets, and components are all adjustable.
5. Use one integration for six tools. They compose and embed freely rather than requiring six separate integrations.

The site offers a copyable SDK prompt, a live demo, and documentation as entry points.

Where it fits, and where it does not

Choose Univer when you are building a product where agents and humans edit office files together, you need cross-file context and synchronized references, and you want to self-host with your own auth and data layer.

Look elsewhere if you want a finished end-user office app, or if you need a single spreadsheet component with no document, slide, canvas, table, or PDF surface. The site does not publish pricing or a hosted sign-up flow, so treat it as an SDK to evaluate and self-host rather than a service with a free tier — verify licensing and deployment terms with the project before committing.

Univer's Office SDK is the entry point for developers who want to embed office tools and agent workflows directly into their own product. You use it to build all six office tools — spreadsheets, docs, slides, canvases, relational tables, and PDFs — plus multi-agent workflows on worktrees, inside your own application. It fits teams that want to design their own UI/UX, self-host the runtime, and connect their own auth, databases, and knowledge bases rather than adopt a finished end-user app.

What the SDK gives you

The SDK is described as one integration for six office tools that you can compose and embed freely. Instead of stitching together separate libraries for each file type, you integrate once and get the whole runtime.

• Six tools, one runtime. Spreadsheets, docs, slides, canvases, relational tables, and PDFs share the same storage and computation layer.
• Composable and embeddable. Tools can be combined and embedded into each other — a slide can hold a live sheet, a doc can cite its source, a canvas can lay it all out.
• Synchronized data. Because sources and references share one runtime, when a source changes, references update.
• Multi-agent workflows on worktrees. Parallel by default, with human-reviewed changes by design.
• Agent compatibility. The site lists OpenCode, Claude Code, OpenClaw, Hermes, Codex, WorkBuddy, and Kimi Work as supported agents.

What you can customize

The SDK is positioned for teams that need control below the surface, not just a themed widget.

• Build your own UI and UX. The SDK provides the engine; you design the interface.
• Self-host. Run it on your own infrastructure and connect your own auth, databases, and knowledge bases.
• Customize down to the engine. Formulas, assets, and components are all customizable.
• One integration, six tools. You don't maintain six separate integrations.

How to get started

1. Go to the Univer site and open the SDK section. The page presents two paths: "Build with SDK" and "Read the docs."
2. Copy the SDK prompt. The site provides a "Copy SDK prompt" action, which is the fastest way to hand the integration context to your agent or development environment.
3. Read the docs. The documentation is the authoritative source for setup, APIs, and configuration.
4. Start from the GitHub repository. The site links to GitHub for building with the SDK.
5. Try the live demos first if you want to see behavior before integrating. The page offers live demos for the spreadsheet and docs tools.

What each tool covers

The runtime is not a thin wrapper around a grid or a text box. Each tool is a full engine.

Spreadsheet

• Full spreadsheet engine with web rendering of 10 million cells and smooth scrolling.
• Runs in the browser and on the server, with real-time collaboration built in.
• Formula execution with 500+ built-in functions, conditional formatting, data validation, PivotTables, sparklines, and filtering.
• Freeze panes, group rows and columns, merge cells, tables, and number formats.
• 31 editable chart types, 180+ shapes, rich text, floating pictures, pictures in cells, and hyperlinks.

Docs

• Full typesetting engine with Word-class layout and Notion-like editing.
• Runs in the browser and on the server, with real-time collaboration built in.
• Headers and footers, pagination, headings, section breaks, multi-column layout, and page size and orientation.
• Tables, pictures, bulleted and numbered lists.

Choosing between SDK and live demos

Common sticking points

• The SDK is not a hosted product. You self-host and connect your own auth, databases, and knowledge bases, so plan for that infrastructure work.
• UI is yours to build. The SDK gives you the engine and components; the interface is your responsibility.
• Agent support is a list, not a guarantee. The site names specific agents; verify your target agent against the docs.
• Pricing and login requirements are not stated on the page. Don't assume the SDK is free or requires no account — check the docs and GitHub for current terms.

For the exact setup steps, API surface, and current terms, use the documentation and GitHub links on univer.ai rather than relying on the marketing page alone.

Univer unifies six office tools — Spreadsheet, Docs, Slides, Canvas, Relational Table, and PDF Editor — by running them on a single runtime that shares the same storage and computation layer. Instead of stitching together separate file formats and engines, all six tools live inside one .univer file, where blocks of different types can compose and embed freely and stay synchronized. This matters if you want agents and humans to work across multiple file types without losing context or manually reconciling data between them.

The core mechanism: one runtime, shared storage and computation

The unifying idea is that the six tools are not separate products glued together. They share:

• The same storage — content from every tool type is held in one place rather than in isolated files.
• The same computation — formulas, references, and derived values are computed against a common layer.

Because storage and computation are shared, a change in one block can propagate to anything that references it. The site describes this as "Data stays synchronized — sources change, references update."

What this looks like in practice

The clearest example given is composition across types: a slide can hold a live sheet, a doc can cite its source, and a canvas can lay it all out. These aren't static embeds — the embedded content remains connected to its origin, so when the source changes, the reference updates.

The six tools in the runtime

The point of the table isn't feature comparison — it's that all six are addressed through one integration, and they can be "composed and embedded freely."

The .univer file as the container

Rather than exporting between formats, Univer keeps multi-type content in a single .univer file. Within that file:

• Every block lives in one place.
• Blocks of different types can reference each other.
• Humans and agents co-edit the same file, and every change is traceable.

This is what makes cross-type references stable: a doc citing its source, or a slide holding a live sheet, works because both live in the same container under the same runtime.

Why this matters for agent workflows

Univer describes itself as "the office harness for AI agents" — an agent-native runtime. Two properties follow from the unified design:

1. Agents work across every file type without losing context. Because the tools share storage and computation, an agent doesn't need to translate between formats or re-establish context when moving from a sheet to a doc to a slide.
2. Parallel work is isolated and reviewable. Univer supports Multi-Agent Workflows on Worktrees — parallel by default, human-reviewed by design — with isolated worktrees and human-reviewed changes.

The site lists compatibility with a range of agents, including OpenCode, Claude Code, OpenClaw, Hermes, Codex, WorkBuddy, and Kimi Work.

How to start building

Univer offers an Office SDK for embedding all six tools and the multi-agent worktree workflows inside your own product. Per the site, with the SDK you can:

• Build your own UI and UX.
• Self-host and connect your own auth, databases, and knowledge bases.
• Customize formulas, assets, and components down to the engine.
• Use one integration for six office tools, composed and embedded freely.

Entry points referenced on the page: the SDK prompt (copyable), the docs, a live demo, and the GitHub repository.

What to keep in mind

• The unification claim rests on shared storage and computation — the value shows up when content of different types references each other, not when you use a single tool in isolation.
• Synchronization is described as automatic ("sources change, references update"), which is the property to verify against your own use case.
• The page does not state pricing, licensing terms, or login requirements, so treat availability and cost as things to confirm directly before committing.

Univer runs multiple AI agents in parallel by giving each one an isolated worktree, so their edits never collide, and then routes every change through human review before it lands in the shared file. This applies when you are building on the Univer Office SDK or using its agent runtime with supported agents such as Claude Code, Codex, OpenCode, OpenClaw, Hermes, WorkBuddy, or Kimi Work. The design goal is stated directly on the site: "Parallel by default, human-reviewed by design."

What a worktree is here

A worktree is an isolated working copy of the office file and its surrounding context. Instead of pointing several agents at one live document, Univer gives each agent its own branch of the work. Because the copies are separate, two agents can edit the same spreadsheet or doc at the same time without overwriting each other.

This matters because office files are stateful: a formula depends on cells, a slide embeds a live sheet, a doc cites a source. If agents wrote into one shared file concurrently, you would get conflicting references and broken layouts. Isolation removes that class of conflict before it happens.

The workflow, step by step

1. Define the task and split it. You describe the work (for example, "update the Q3 forecast sheet and refresh the summary doc"). The runtime can fan this out across multiple agents rather than running one agent serially.
2. Each agent gets its own worktree. The agent operates on an isolated copy, so its reads and writes stay local to that branch.
3. Agents run in parallel. Multiple agents work simultaneously across file types — spreadsheets, docs, slides, canvases, relational tables, and PDFs — without losing context, since they share the same underlying storage and computation model.
4. Changes come back for review. Each worktree's output is presented as a reviewable change rather than being merged automatically. A human inspects it.
5. Approved changes merge; rejected ones are discarded. Only reviewed changes reach the shared file, keeping every change traceable.

The key property is that parallelism and safety are handled by the same mechanism: isolation makes concurrency possible, and review makes it safe.

Why human review is built in, not bolted on

Agents are good at producing volume and bad at knowing when a change is wrong for your business. In an office file, a plausible-looking edit can silently break a reference chain — a source cell changes, and every dependent formula, chart, or cited block shifts with it.

Univer's answer is to keep the human in the merge path. The site frames this as "human-reviewed by design" and "every change traceable." Practically, that means you are not approving a black-box result; you are reviewing a diff against an isolated copy, which is a far smaller and more legible thing to check.

How this fits the rest of the runtime

The multi-agent workflow is not a separate product bolted onto an editor. It sits on the same runtime that powers the six office tools:

Because a slide can hold a live sheet and a doc can cite its source, an agent editing one block can affect another. Worktree isolation plus review is what keeps that composition from turning into a cascade of unintended edits.

What you need to run it

• An agent that Univer supports. The site lists OpenCode, Claude Code, OpenClaw, Hermes, Codex, WorkBuddy, and Kimi Work.
• The Univer Office SDK if you are embedding this in your own product. The SDK lets you build your own UI and UX, self-host, and connect your own auth, databases, and knowledge bases.
• A review step in your process. The workflow assumes a human decides what merges. If you skip that, you lose the guarantee the design is built around.

Customization runs down to the engine level — formulas, assets, and components — so the runtime can be shaped to your file types and conventions rather than forcing your content into a fixed model.

Where to start

The site offers a live demo for the spreadsheet and docs tools, a "Copy SDK prompt" action, and a "Read the docs" link, plus a GitHub entry point for building with the SDK. If you want to see the multi-agent behavior before committing, the demo is the fastest way to understand how isolated worktrees and reviewable changes feel in practice.

The short version: Univer makes agents fast by running them in parallel on isolated copies, and keeps them safe by making a human approve what actually lands.