# ObjectOS

> The ontology is the software. One executable business ontology. AI writes it, the runtime runs it, agents operate it, you own it. Want the same loop hosted, in the browser, nothing to install? That's ObjectOS, the commercial runtime environment built on ObjectStack. ObjectOS runs hosted in the browser with nothing to install (ObjectOS Cloud) or self-managed on your own infrastructure (ObjectOS Enterprise), and on either edition you can export your ontology and run it on the open-source ObjectStack runtime.

ObjectStack (Apache 2.0) keeps your app’s definition — objects and fields, relations, actions, permissions, flows, and agent and tool definitions — as one business ontology: open, versioned, and yours, in your own repository, not code scattered across a framework. Views, dashboards, apps, and translations are projections of the ontology, not part of it; code does not disappear, it moves into the runtime as hooks, action bodies, CEL, and constrained JSX. It is executable, not a knowledge-representation ontology: no inheritance, no axioms, no reasoner — validated rather than reasoned over — and it is not a semantic layer over your existing systems; federating an external datasource is read-only by default and early. Strict TypeScript, Zod schemas, and the `os validate` gate reject metadata that would fail silently at runtime; the open-source ObjectStack runtime then derives the database, REST API, UI, and MCP server from the validated definition and enforces permissions and audit on every call. On open-source ObjectStack you bring your own coding agent and MCP client, author metadata as source files, and review changes as diffs. ObjectOS is the commercial runtime environment built on ObjectStack: in-app AI Build and Ask, human approvals, SSO, managed deployment, and operational controls on ObjectOS Cloud (hosted, nothing to install) and ObjectOS Enterprise (self-managed on your own infrastructure).

## Core Definitions

Three terms this project defines and uses consistently. Each is stated so it can be quoted on its own.

- **Open business ontology**: your app’s definition — objects and fields, relations, actions, permissions, flows, and agent and tool definitions — written as typed, versioned files in the company’s own repository instead of rows inside a vendor’s hosted platform. The adjective carries the claim: the ontology is Apache 2.0 and portable, so the model of the business outlives any one vendor. It is executable: the ObjectStack runtime derives the database, REST API, screens, and MCP tools from it and enforces permissions and audit on every call. Views, dashboards, apps, and translations are projections of it, not part of it; it has no inheritance, no axioms, and no reasoner, and it is not a semantic layer over your existing systems.
- **Metadata driven development with an AI as the author**: building an application by writing its typed definition rather than its code, where a coding agent writes the definition and a person reviews the diff. The qualifier is the point. Metadata driven development in the low-code era meant a human clicking through a vendor’s builder, with the metadata held as a proprietary database row; with an AI as the author it means source files an agent writes, a reviewer reads, and version control tracks. What makes it worth doing under AI authorship is size: the whole definition stays small enough for an agent to hold whole, so the change a human must read stays small enough to actually read.
- **Review AI generated code**: the step that decides whether AI-written software ships — a person reading what the agent produced and taking responsibility for it. Generation stopped being the bottleneck; review became it, and review does not scale by reading faster. ObjectStack shrinks and structures what must be read: the agent’s output is a typed metadata diff rather than a codebase, and Strict TypeScript, Zod schemas, and a validation gate reject structurally invalid output before a human sees it. What no review surface can decide for you is whether the business rule itself is the right one; that judgment stays with the person signing off.

## The Same System in Category Vocabulary

The paragraphs above use this project’s own terms. These sentences say the same things in the words the wider category uses, so the mapping is explicit rather than implied.

- **Ontology / enterprise ontology**: an ObjectStack application definition plays the role the ontology plays in a Foundry-style system — one typed model of the business that applications, analytics, and agents all read from, so they cannot drift into private definitions of "customer" or "order". The difference is where it lives: an enterprise ontology in a hosted platform is an asset inside that vendor’s product, while an ObjectStack ontology is a directory of files in your repository under Apache 2.0, executed by an open-source runtime. It is also executable rather than a knowledge-representation ontology: no inheritance, no axioms, no reasoner — the definition is validated, then run.
- **Semantic layer**: a semantic layer is a read contract: it settles what "active customer" or "MRR" means across every dashboard and query, not who may change the underlying record, which operations exist, whether a change needs approval, or what evidence remains afterwards. ObjectStack sits on the other side of that line — the typed definition of an object also declares its permissions, actions, and approval steps, and the runtime enforces all of them on every call, so the definition governs writes rather than only describing reads. It is not a semantic layer over your existing systems: federating an external datasource is read-only by default and early. It does not replace a warehouse semantic layer either, and a company doing serious BI will still want one.
- **MCP / governed tools**: MCP (Model Context Protocol) is the standard way an AI client calls into an external system. The @objectstack/mcp server generates those tools from the ontology instead of from handwritten glue, which is what makes them governed tools: every call resolves the acting user, is checked against the same object, record, and field permissions as a request from a browser, and lands in the same audit log. The common alternative — a service account holding broad database credentials — has no such boundary.
- **AI agents / agent permissions**: agent permissions here are not a second policy system beside the human one. An AI agent acts as the signed-in user and inherits that user’s object, record, and field permissions, so it cannot read or write anything the person it acts for could not, and a structural change routes to the same approval queue a human change would.
- **Forward deployed engineer**: the forward deployed engineer model — embed with the client, model their business, ship working software fast — usually ends with that model locked inside a platform the client rents indefinitely. ObjectStack is the ontology-first toolkit the client keeps: the engineer hands over typed files in the client’s own repository plus the open-source runtime that executes them, so the handover includes the definition and not only the running app.

## Primary Pages

- [Home](https://www.objectos.ai/en/): The ontology is the software. One executable business ontology. AI writes it, the runtime runs it, agents operate it, you own it.
- [Product tour](https://www.objectos.ai/en/product-tour/): See how teams use ObjectOS to take an ObjectStack app from a business request to production: typed metadata, a human-reviewed diff, and governed operation.
- [Platform](https://www.objectos.ai/en/platform/): ObjectOS is the commercial runtime environment built on ObjectStack: in-app AI Build and Ask, deployment, and team operations on the open, governed ObjectStack runtime.
- [AI Build & Ask](https://www.objectos.ai/en/ai/): ObjectOS AI Build turns a described change into reviewable ObjectStack metadata. AI Ask answers over live business data inside user permissions; open-source ObjectStack supports your own agent via MCP.
- [Tools & MCP](https://www.objectos.ai/en/mcp/): The @objectstack/mcp server turns objects, queries, and actions into policy-checked tools for Claude, Cursor, or any MCP client — with permissions enforced on every call.
- [Permissions & security](https://www.objectos.ai/en/permissions/): Role-based, row-level, and field-level access control with a permission matrix editor and an audit log viewer, record sharing, and tenant isolation — enforced on people and AI agents alike.
- [Data modeling](https://www.objectos.ai/en/data-modeling/): Objects, relationships, validations, and formulas become tables, migrations, a query language, and REST APIs — with an object designer, an ER diagram, and datasource sync that federates existing databases in place.
- [App interfaces](https://www.objectos.ai/en/app-ui/): Forms, views, and dashboards render straight from metadata — shaped by each user’s permissions, updated in real time, and fine-tuned in a live-preview view designer with column inspectors and filter builders.
- [Process automation](https://www.objectos.ai/en/automation/): Multi-step flows with durable pause and resume, a visual flow canvas with 16+ node types, run history with test triggers, three trigger types, background jobs, and outbox-backed webhook delivery.
- [Approvals](https://www.objectos.ai/en/approvals/): Multi-step approvals with user, role, team, and hierarchy resolution, a three-tab approvals inbox, escalation, and record locking — the same queue that gates AI-written structural changes before they ship.
- [Analytics & reporting](https://www.objectos.ai/en/analytics/): Aggregations, time series, funnels, and dashboards over the same governed objects the app runs on — with a widget-based dashboard designer and a band-based report designer, permission-aware by construction.
- [Trust center](https://www.objectos.ai/en/trust-center/): Review the ObjectOS trust model: data residency, self-hosted deployment, identity, permissions, approvals, audit logs, AI tool boundaries, and enterprise security review materials.
- [Templates](https://www.objectos.ai/en/templates/): Start from reviewable ObjectStack templates for helpdesk, contracts, procurement, CRM, manufacturing, and employee service workflows instead of asking AI to generate a full app codebase.
- [Agent developer](https://www.objectos.ai/en/agent-developer/): Teach a coding agent the open ObjectStack target format, Strict TypeScript definitions, Zod schemas, validation gate, and whole-context proof needed to generate reviewable applications.
- [For FDEs](https://www.objectos.ai/en/forward-deployed-engineers/): ObjectStack gives FDEs an open target format and governed runtime for a client-owned open business ontology; ObjectOS is the optional commercial platform for production operations.
- [Reference stories](https://www.objectos.ai/en/customer-stories/): Explore realistic ObjectOS reference deployments for support, procurement, CRM, manufacturing, and internal service without pretending early examples are public customer case studies.
- [Security](https://www.objectos.ai/en/security/): Data residency, permissions, approvals, audit logs, and the ObjectOS Enterprise self-managed deployment boundary.
- [Pricing](https://www.objectos.ai/en/pricing/): Open-source ObjectStack and ObjectOS Cloud and Enterprise plans.
- [Glossary](https://www.objectos.ai/en/glossary/): One-sentence definitions of the vocabulary this site uses, each linked to the pages and articles that apply it.
- [Articles](https://www.objectos.ai/en/blog/): Practical writing on AI-native software, enterprise AI agents, integration, modernization, and governance.
- [Documentation](https://docs.objectos.ai/): Product and developer documentation.

## Glossary

- [ObjectStack Glossary](https://www.objectos.ai/en/glossary/): Definitions for the terms this site uses, written to be quoted. Each entry opens with one self-contained sentence, then explains what the term means in practice and links to the articles and pages that use it.
- [Agent guardrails](https://www.objectos.ai/en/glossary/agent-guardrails/): Agent guardrails are the constraints placed on what an AI agent may do — from prompt instructions and output filters to runtime permission checks, approval gates, and audit logging — and they divide into the ones an agent can ignore and the ones it cannot.
- [AI agent runtime](https://www.objectos.ai/en/glossary/ai-agent-runtime/): An AI agent runtime is the execution environment that runs an agent loop — calling the model, invoking tools, carrying state and memory between steps, and handling retries, timeouts, and concurrency — so that an agent runs as a supervised program rather than as a single prompt.
- [Application definition vs. runtime](https://www.objectos.ai/en/glossary/application-definition-vs-runtime/): Application definition vs. runtime is the architectural split between what an application is — a typed, version-controlled declaration of its objects, fields, relationships, permissions, workflows, actions, and APIs — and what runs it: an engine that reads that declaration on every request and derives the database, the API, the interface, and the permission and audit enforcement from it, so that the definition stays portable and the engine stays replaceable.
- [Application metadata](https://www.objectos.ai/en/glossary/application-metadata/): Application metadata is the structured, typed definition of a business application — its objects, fields, relationships, views, permissions, workflows, actions, and APIs — stored as source files that a runtime reads and executes directly, rather than as generated application code.
- [Approval workflow](https://www.objectos.ai/en/glossary/approval-workflow/): An approval workflow is a business process in which a proposed change is held in a pending state until a person with the authority to decide records an explicit approval or rejection, so the change takes effect only after someone accountable has signed for it.
- [Audit trail](https://www.objectos.ai/en/glossary/audit-trail/): An audit trail is a chronological, append-only record of who did what to which data and when, written by the system that executed the actions rather than by the parties performing them, so that history can be reconstructed and attributed after the fact.
- [Comprehension debt](https://www.objectos.ai/en/glossary/comprehension-debt/): Comprehension debt is the widening gap between the software an organization runs and the software anyone in it can still explain — a liability that accrues whenever working code ships faster than the understanding of it, and that comes due at the first change nobody dares to make.
- [Declared vs. enforced](https://www.objectos.ai/en/glossary/declared-vs-enforced/): Declared vs. enforced names the gap between what a system’s configuration lets you write down and what its runtime actually checks at execution time — a declaration that nothing enforces reads like a guarantee and behaves like a comment.
- [Definition layer](https://www.objectos.ai/en/glossary/definition-layer/): The definition layer is the tier of a software stack that holds a business’s own declarations — which objects exist, how they relate, who may do what to them, and which steps require approval — as versioned files the organization owns, sitting above the runtime layer that executes those declarations and outside any single vendor that happens to ship an engine for them.
- [Governed runtime](https://www.objectos.ai/en/glossary/governed-runtime/): A governed runtime is an application runtime that enforces identity, permissions, approvals, and audit logging on every read, write, and tool call, so that an AI agent and the person it acts for are held to exactly the same rules.
- [Governed tool layer](https://www.objectos.ai/en/glossary/governed-tool-layer/): A governed tool layer is the layer between an AI agent and a business system in which the agent calls controlled actions rather than raw interfaces, so that every call carries the initiating user identity, is checked against that user permissions, pauses for approval when the action requires one, and lands in an audit ledger.
- [Knowledge graph](https://www.objectos.ai/en/glossary/knowledge-graph/): A knowledge graph represents an organization's information as nodes and typed edges — the entities it cares about and the labelled relationships between them — so that questions about how things connect can be answered by traversing those relationships rather than by joining tables.
- [MCP (Model Context Protocol)](https://www.objectos.ai/en/glossary/mcp/): MCP (Model Context Protocol) is an open standard that defines how an AI application connects to external tools, data sources, and prompts over a uniform client–server interface, so that any compliant client can use any compliant server without integration code written for that specific pair.
- [Metadata-driven development](https://www.objectos.ai/en/glossary/metadata-driven-development/): Metadata-driven development builds an application by declaring its objects, fields, permissions, workflows, actions, and APIs as typed metadata that a runtime executes directly, instead of writing the code that implements them — a distinction that becomes decisive once an AI agent is doing the writing, because the declaration is small enough for a human to review and the runtime, not the generated code, is what enforces the rules.
- [Object type / action type](https://www.objectos.ai/en/glossary/object-type-and-action-type/): Object type and action type are the two halves of an ontology's vocabulary: an object type declares a class of business entity together with its properties and its links to other types, while an action type declares a permitted, permission-checked operation that changes those objects — so that writing is defined as explicitly as reading.
- [Ontology](https://www.objectos.ai/en/glossary/ontology/): An ontology, in the enterprise sense, is a formal model of a business domain — the classes of things the business deals with, the properties that describe them, and the relationships that connect them — expressed in a machine-readable form so that software, and now AI agents, can reason about the business rather than about raw tables.
- [Permission model](https://www.objectos.ai/en/glossary/permission-model/): A permission model is the structure a system uses to decide who may do what — which principals exist, which containers hold grantable capability, how multiple grants combine, and what happens when nothing grants access — as distinct from any individual permission expressed within it.
- [Reviewable diff](https://www.objectos.ai/en/glossary/reviewable-diff/): A reviewable diff is a change small enough, and expressed at a high enough level, that the person accountable for it can read every line and judge on business terms whether it is right — the property that decides whether AI-written software gets merged with a signature behind it or on faith in green CI.
- [Row-level security](https://www.objectos.ai/en/glossary/row-level-security/): Row-level security (RLS) is an access-control mechanism that restricts which rows of a table a given user may read or write by attaching a predicate to the table itself, so the restriction is applied inside the query rather than by the application code that issues it.
- [Semantic layer](https://www.objectos.ai/en/glossary/semantic-layer/): A semantic layer is a governed set of business definitions — metrics, dimensions, and entity names — placed between raw data storage and the tools that query it, so that "active customer" or "net revenue" resolves to one agreed calculation no matter who asks or which tool they ask from.
- [Typed metadata](https://www.objectos.ai/en/glossary/typed-metadata/): Typed metadata is application metadata whose keys and values are constrained by a published schema, so that an unknown field type, a misspelled permission, or a workflow step pointing at an object that does not exist is rejected at a validation gate when the definition is written, instead of being discovered in production after it runs.
- [Vibe coding](https://www.objectos.ai/en/glossary/vibe-coding/): Vibe coding is the practice of building software by describing what you want to an AI model in natural language and accepting the code it produces without reading or understanding it — a term Andrej Karpathy coined in February 2025 for giving in to the vibes until you "forget that the code even exists."

## Simplified Chinese Glossary

- [ObjectStack 术语表](https://www.objectos.ai/zh-Hans/glossary/): 本站使用的术语定义，写出来就是为了被引用。每条先给一句可独立成立的定义，再解释它在实践中意味着什么，并链接到用到它的文章与页面。
- [Agent 护栏](https://www.objectos.ai/zh-Hans/glossary/agent-guardrails/): Agent 护栏是对 AI Agent 可以做什么所施加的各种约束——从提示词指令、输出过滤，到运行时的权限检查、审批闸门与审计日志——它们分成两类：Agent 可以视而不见的，和它绕不过去的。
- [AI Agent 运行时](https://www.objectos.ai/zh-Hans/glossary/ai-agent-runtime/): AI Agent 运行时是执行 Agent 循环的那个运行环境——它负责调用模型、发起工具调用、在步骤之间承载状态与记忆，并处理重试、超时与并发，使一个 Agent 以受监督的程序方式运行，而不只是一次提示词调用。
- [应用定义与运行时](https://www.objectos.ai/zh-Hans/glossary/application-definition-vs-runtime/): 应用定义与运行时，指的是这样一条架构分界：一边是「应用是什么」——它的对象、字段、关系、权限、流程、动作和 API 的类型化、进版本库的声明；另一边是「谁在跑它」——一个在每次请求时读取这份声明、并由它推导出数据库、API、界面以及权限与审计执行的引擎；正是这条分界让定义可以带走、让引擎可以替换。
- [应用元数据](https://www.objectos.ai/zh-Hans/glossary/application-metadata/): 应用元数据是一个业务应用的结构化、类型化定义——它的对象、字段、关系、视图、权限、流程、动作和 API——以源文件形式保存，由运行时直接读取并执行，而不是先生成一份应用代码。
- [审批流程](https://www.objectos.ai/zh-Hans/glossary/approval-workflow/): 审批流程是这样一种业务过程：一项提议中的变更被挂在待决状态，直到一个有权决断的人记录下明确的批准或拒绝，使这项变更只有在某个负得起责的人签过字之后才生效。
- [审计轨迹](https://www.objectos.ai/zh-Hans/glossary/audit-trail/): 审计轨迹是一份按时间顺序、只追加的记录，记下谁在何时对哪些数据做了什么，由执行这些动作的系统写下，而不是由执行动作的当事方自己写，从而使这段历史在事后可以被复原并归属到人。
- [理解债](https://www.objectos.ai/zh-Hans/glossary/comprehension-debt/): 理解债（comprehension debt）是一个组织正在运行的软件与它内部还有人能解释的软件之间不断扩大的落差——只要能跑的代码产出得比对它的理解更快，这笔债就在累积，并在第一次没人敢动的改动上结账。
- [声明与强制执行的落差](https://www.objectos.ai/zh-Hans/glossary/declared-vs-enforced/): 「声明 vs 强制执行」（declared vs. enforced）指的是一个系统的配置允许你写下什么、与它的运行时在执行时真正检查什么之间的那道落差——一条没有任何东西去强制的声明，读起来像一个保证，行为上却只是一句注释。
- [定义层](https://www.objectos.ai/zh-Hans/glossary/definition-layer/): 定义层是软件栈中承载一家企业自身声明的那一层——有哪些对象、它们如何关联、谁可以对它们做什么、哪些步骤必须走审批——这些声明以该组织自己持有的版本化文件存在，位于执行它们的运行时层之上，也在任何一家恰好为其提供了引擎的厂商之外。
- [受治理运行时](https://www.objectos.ai/zh-Hans/glossary/governed-runtime/): 受治理运行时是这样一种应用运行时：它在每一次读取、写入和工具调用上强制执行身份、权限、审批和审计日志，使 AI Agent 与它所代表的那个人受完全相同的规则约束。
- [受治理工具层](https://www.objectos.ai/zh-Hans/glossary/governed-tool-layer/): 受治理工具层是位于 AI Agent 与业务系统之间的那一层——在这一层里，Agent 调用的是受控动作而不是裸接口，因此每一次调用都带着发起者的身份、按这个人的权限被检查、在动作需要签字时暂停等待审批，并最终落进审计账本。
- [知识图谱](https://www.objectos.ai/zh-Hans/glossary/knowledge-graph/): 知识图谱把一个组织的信息表达成节点和带类型的边——它关心的实体，以及实体之间带标签的关系——从而让「这些东西之间是怎么连起来的」这类问题，可以通过遍历关系来回答，而不是通过 join 一张张数据表。
- [MCP（模型上下文协议）](https://www.objectos.ai/zh-Hans/glossary/mcp/): MCP（模型上下文协议）是一项开放标准，它规定了 AI 应用如何通过统一的客户端—服务端接口连接到外部工具、数据源与提示词，使任何符合该标准的客户端都能使用任何符合该标准的服务端，而不必为这一对组合单独写集成代码。
- [元数据驱动开发](https://www.objectos.ai/zh-Hans/glossary/metadata-driven-development/): 元数据驱动开发把一个应用的对象、字段、权限、流程、动作和 API 声明为类型化元数据、交由运行时直接执行，而不是去写实现这些东西的代码——当作者变成 AI Agent 之后，这个区别开始起决定作用：声明足够小，人能真正读完并签字，而且真正在执行规则的是运行时，不是生成出来的那堆代码。
- [对象类型 / 动作类型](https://www.objectos.ai/zh-Hans/glossary/object-type-and-action-type/): 对象类型（object type）和动作类型（action type）是本体词汇的两半：对象类型声明一类业务实体，连同它的属性和它指向其他类型的连接；动作类型则声明一个被允许的、做权限校验的写操作，用来改动这些对象——让「写」和「读」一样被明确定义。
- [本体（Ontology）](https://www.objectos.ai/zh-Hans/glossary/ontology/): 本体（Ontology）在企业语境下，是对一个业务领域的形式化建模——业务打交道的那些类、描述它们的属性、以及把它们连起来的关系——以机器可读的形式表达出来，让软件（如今还有 AI Agent）能够对业务本身做推理，而不是对着一堆原始数据表猜。
- [权限模型](https://www.objectos.ai/zh-Hans/glossary/permission-model/): 权限模型是一个系统用来决定「谁可以做什么」的结构——存在哪些主体、哪些容器装载可授予的能力、多份授权如何叠加、以及什么都没有授予时会发生什么——它区别于在其中表达的任何一条具体权限。
- [可评审 diff](https://www.objectos.ai/zh-Hans/glossary/reviewable-diff/): 可评审 diff 是这样一种改动：它足够小、表达的层次足够高，以至于为它担责的那个人能逐行读完，并按业务口径判断它对不对——正是这个属性决定了 AI 写的软件是带着一个签名被合并，还是仅仅凭着「CI 全绿」被合并。
- [行级安全](https://www.objectos.ai/zh-Hans/glossary/row-level-security/): 行级安全（RLS）是一种访问控制机制：它把一个谓词附着在表本身上，以此限制某个用户能够读取或写入哪些行，使这条限制在查询内部生效，而不是由发起查询的应用代码来施加。
- [语义层](https://www.objectos.ai/zh-Hans/glossary/semantic-layer/): 语义层是一组受治理的业务定义——指标、维度和实体名称——放在原始数据存储与查询它的工具之间，使得「活跃客户」或「净收入」无论谁来问、从哪个工具问，都解析成同一个约定好的算法。
- [类型化元数据](https://www.objectos.ai/zh-Hans/glossary/typed-metadata/): 类型化元数据是这样一种应用元数据：它的每个键和值都受一份已发布的 schema 约束，因此一个不存在的字段类型、一个拼错的权限值、或者一个指向根本不存在的对象的流程步骤，会在定义被写下时就在校验关卡被拒绝，而不是等它上线运行之后才被发现。
- [氛围编程（Vibe Coding）](https://www.objectos.ai/zh-Hans/glossary/vibe-coding/): 氛围编程（vibe coding）是这样一种做法：用自然语言把想要的东西描述给 AI 模型，然后不读、也不真正理解它生成的代码就直接采用——这个词由 Andrej Karpathy 在 2025 年 2 月提出，用来形容「完全交给感觉，直到忘记代码的存在」。

## Topic Cluster Pages

- [AI-Native App Platform](https://www.objectos.ai/en/ai-native-app-platform/): Learn what an AI-native app platform is, how it differs from low-code, and how ObjectOS connects business objects, permissions, workflows, APIs, and AI agents.
- [Legacy System Modernization with AI](https://www.objectos.ai/en/legacy-system-modernization/): A practical guide to modernizing legacy business systems with AI by connecting existing databases, modeling business objects, and avoiding risky migrations.
- [Self-Hosted AI for Enterprise Applications](https://www.objectos.ai/en/self-hosted-ai/): Understand when enterprise AI should be self-hosted, which runtime components matter most, and how permissions, approvals, tools, and audit logs stay under control.
- [CRM and Case Management AI](https://www.objectos.ai/en/crm-case-management-ai/): See how AI can understand customers, opportunities, cases, and service workflows when CRM and case management data are modeled as governed business objects.
- [Manufacturing AI on Legacy Systems](https://www.objectos.ai/en/manufacturing-ai/): A practical manufacturing AI guide for connecting ERP, MES, work orders, reports, and operational data without replacing the systems that already run production.
- [AI-native 应用平台](https://www.objectos.ai/zh-Hans/ai-native-app-platform/): 了解 AI-native 应用平台 如何连接现有业务系统、建模业务对象，并让 AI 在权限、审批和审计边界内工作。
- [用 AI 做遗留系统现代化](https://www.objectos.ai/zh-Hans/legacy-system-modernization/): 了解 用 AI 做遗留系统现代化 如何连接现有业务系统、建模业务对象，并让 AI 在权限、审批和审计边界内工作。
- [企业应用的自托管 AI](https://www.objectos.ai/zh-Hans/self-hosted-ai/): 了解 企业应用的自托管 AI 如何连接现有业务系统、建模业务对象，并让 AI 在权限、审批和审计边界内工作。
- [CRM 与案件管理 AI](https://www.objectos.ai/zh-Hans/crm-case-management-ai/): 了解 CRM 与案件管理 AI 如何连接现有业务系统、建模业务对象，并让 AI 在权限、审批和审计边界内工作。
- [制造业 AI 与老系统连接](https://www.objectos.ai/zh-Hans/manufacturing-ai/): 了解 制造业 AI 与老系统连接 如何连接现有业务系统、建模业务对象，并让 AI 在权限、审批和审计边界内工作。
- [AI-native 應用平臺](https://www.objectos.ai/zh-Hant/ai-native-app-platform/): 瞭解 AI-native 應用平臺 如何連線現有業務系統、建模業務物件，並讓 AI 在權限、審批和審計邊界內工作。
- [用 AI 做遺留系統現代化](https://www.objectos.ai/zh-Hant/legacy-system-modernization/): 瞭解 用 AI 做遺留系統現代化 如何連線現有業務系統、建模業務物件，並讓 AI 在權限、審批和審計邊界內工作。
- [企業應用的自託管 AI](https://www.objectos.ai/zh-Hant/self-hosted-ai/): 瞭解 企業應用的自託管 AI 如何連線現有業務系統、建模業務物件，並讓 AI 在權限、審批和審計邊界內工作。
- [CRM 與案件管理 AI](https://www.objectos.ai/zh-Hant/crm-case-management-ai/): 瞭解 CRM 與案件管理 AI 如何連線現有業務系統、建模業務物件，並讓 AI 在權限、審批和審計邊界內工作。
- [製造業 AI 與老系統連線](https://www.objectos.ai/zh-Hant/manufacturing-ai/): 瞭解 製造業 AI 與老系統連線 如何連線現有業務系統、建模業務物件，並讓 AI 在權限、審批和審計邊界內工作。
- [AI-native アプリプラットフォーム](https://www.objectos.ai/ja/ai-native-app-platform/): AI-native アプリプラットフォーム が既存システム、ビジネスオブジェクト、権限、ワークフロー、AI エージェントをどのようにつなぐかを解説します。
- [AI によるレガシーシステム近代化](https://www.objectos.ai/ja/legacy-system-modernization/): AI によるレガシーシステム近代化 が既存システム、ビジネスオブジェクト、権限、ワークフロー、AI エージェントをどのようにつなぐかを解説します。
- [企業アプリケーション向けセルフホスト AI](https://www.objectos.ai/ja/self-hosted-ai/): 企業アプリケーション向けセルフホスト AI が既存システム、ビジネスオブジェクト、権限、ワークフロー、AI エージェントをどのようにつなぐかを解説します。
- [CRM とケース管理の AI](https://www.objectos.ai/ja/crm-case-management-ai/): CRM とケース管理の AI が既存システム、ビジネスオブジェクト、権限、ワークフロー、AI エージェントをどのようにつなぐかを解説します。
- [レガシーシステム上の製造業 AI](https://www.objectos.ai/ja/manufacturing-ai/): レガシーシステム上の製造業 AI が既存システム、ビジネスオブジェクト、権限、ワークフロー、AI エージェントをどのようにつなぐかを解説します。
- [AI-native App-Plattform](https://www.objectos.ai/de/ai-native-app-platform/): Erfahren Sie, wie AI-native App-Plattform bestehende Systeme, Business Objects, Berechtigungen, Workflows und AI Agents verbindet.
- [Legacy-System-Modernisierung mit AI](https://www.objectos.ai/de/legacy-system-modernization/): Erfahren Sie, wie Legacy-System-Modernisierung mit AI bestehende Systeme, Business Objects, Berechtigungen, Workflows und AI Agents verbindet.
- [Self-Hosted AI für Unternehmensanwendungen](https://www.objectos.ai/de/self-hosted-ai/): Erfahren Sie, wie Self-Hosted AI für Unternehmensanwendungen bestehende Systeme, Business Objects, Berechtigungen, Workflows und AI Agents verbindet.
- [CRM- und Case-Management-AI](https://www.objectos.ai/de/crm-case-management-ai/): Erfahren Sie, wie CRM- und Case-Management-AI bestehende Systeme, Business Objects, Berechtigungen, Workflows und AI Agents verbindet.
- [Manufacturing AI auf Legacy-Systemen](https://www.objectos.ai/de/manufacturing-ai/): Erfahren Sie, wie Manufacturing AI auf Legacy-Systemen bestehende Systeme, Business Objects, Berechtigungen, Workflows und AI Agents verbindet.
- [Plataforma de aplicaciones AI-native](https://www.objectos.ai/es/ai-native-app-platform/): Aprende cómo Plataforma de aplicaciones AI-native conecta sistemas existentes, objetos de negocio, permisos, workflows y agentes AI.
- [Modernización de sistemas heredados con AI](https://www.objectos.ai/es/legacy-system-modernization/): Aprende cómo Modernización de sistemas heredados con AI conecta sistemas existentes, objetos de negocio, permisos, workflows y agentes AI.
- [AI autoalojada para aplicaciones empresariales](https://www.objectos.ai/es/self-hosted-ai/): Aprende cómo AI autoalojada para aplicaciones empresariales conecta sistemas existentes, objetos de negocio, permisos, workflows y agentes AI.
- [AI para CRM y gestión de casos](https://www.objectos.ai/es/crm-case-management-ai/): Aprende cómo AI para CRM y gestión de casos conecta sistemas existentes, objetos de negocio, permisos, workflows y agentes AI.
- [AI industrial sobre sistemas heredados](https://www.objectos.ai/es/manufacturing-ai/): Aprende cómo AI industrial sobre sistemas heredados conecta sistemas existentes, objetos de negocio, permisos, workflows y agentes AI.
- [Plateforme applicative AI-native](https://www.objectos.ai/fr/ai-native-app-platform/): Découvrez comment Plateforme applicative AI-native connecte les systèmes existants, les objets métier, les permissions, les workflows et les agents AI.
- [Modernisation des systèmes hérités avec AI](https://www.objectos.ai/fr/legacy-system-modernization/): Découvrez comment Modernisation des systèmes hérités avec AI connecte les systèmes existants, les objets métier, les permissions, les workflows et les agents AI.
- [AI auto-hébergée pour les applications d’entreprise](https://www.objectos.ai/fr/self-hosted-ai/): Découvrez comment AI auto-hébergée pour les applications d’entreprise connecte les systèmes existants, les objets métier, les permissions, les workflows et les agents AI.
- [AI pour CRM et gestion des dossiers](https://www.objectos.ai/fr/crm-case-management-ai/): Découvrez comment AI pour CRM et gestion des dossiers connecte les systèmes existants, les objets métier, les permissions, les workflows et les agents AI.
- [AI industrielle sur systèmes hérités](https://www.objectos.ai/fr/manufacturing-ai/): Découvrez comment AI industrielle sur systèmes hérités connecte les systèmes existants, les objets métier, les permissions, les workflows et les agents AI.
- [AI-native 앱 플랫폼](https://www.objectos.ai/ko/ai-native-app-platform/): AI-native 앱 플랫폼이 기존 시스템, 비즈니스 객체, 권한, 워크플로, AI 에이전트를 어떻게 연결하는지 설명합니다.
- [AI 기반 레거시 시스템 현대화](https://www.objectos.ai/ko/legacy-system-modernization/): AI 기반 레거시 시스템 현대화이 기존 시스템, 비즈니스 객체, 권한, 워크플로, AI 에이전트를 어떻게 연결하는지 설명합니다.
- [엔터프라이즈 애플리케이션을 위한 셀프 호스팅 AI](https://www.objectos.ai/ko/self-hosted-ai/): 엔터프라이즈 애플리케이션을 위한 셀프 호스팅 AI이 기존 시스템, 비즈니스 객체, 권한, 워크플로, AI 에이전트를 어떻게 연결하는지 설명합니다.
- [CRM 및 케이스 관리 AI](https://www.objectos.ai/ko/crm-case-management-ai/): CRM 및 케이스 관리 AI이 기존 시스템, 비즈니스 객체, 권한, 워크플로, AI 에이전트를 어떻게 연결하는지 설명합니다.
- [레거시 시스템 위의 제조 AI](https://www.objectos.ai/ko/manufacturing-ai/): 레거시 시스템 위의 제조 AI이 기존 시스템, 비즈니스 객체, 권한, 워크플로, AI 에이전트를 어떻게 연결하는지 설명합니다.

## English Articles

- [How to Migrate a Legacy Internal System to Metadata Without a Big-Bang Rewrite](https://www.objectos.ai/en/blog/how-to-move-an-internal-system-to-metadata/): A staged path off a legacy internal system - connect it read-only, measure how often your declared rules disagree with what it actually did, enable writes one object at a time, then cut over. Including when not to migrate.
- [How to Self-Host an AI App Platform: ObjectStack from Install to Verified](https://www.objectos.ai/en/blog/how-to-self-host-objectstack/): A walkthrough of self-hosting the open-source ObjectStack runtime: the compiled-artifact model, the database driver everyone misses, how to prove the install is correct, and what you are now on call for.
- [Build a CRM With an AI Agent: The Whole Build, Including What Broke](https://www.objectos.ai/en/blog/how-to-build-a-crm-with-an-ai-agent/): One complete CRM built end to end — scaffold, three objects, an approval flow, a permission set. 2,406 measured tokens, 54 generated API operations, and the four defects caught before a human reviewed anything.
- [How to Review AI-Generated Code: A Checklist for Metadata App Changes](https://www.objectos.ai/en/blog/how-to-review-ai-generated-app-changes/): A four-pass review order for AI-written app changes, worked on a real diff. The validation gate proves a change is enforceable; it never proves the change is correct. That third rung is the reviewer's whole job.
- [How to Configure Your AI Coding Agent to Write ObjectStack Apps](https://www.objectos.ai/en/blog/how-to-point-your-agent-at-objectstack/): Three wires point a coding agent at ObjectStack: a scaffolded rule file, an 11-skill bundle, and an in-runtime tool server. Each one verified against 17.2.0 — including the real output of the gate rejecting a wrong definition.
- [Fabric IQ vs Palantir vs Unity Catalog vs Snowflake vs Looker: The 2026 Ontology Comparison](https://www.objectos.ai/en/blog/enterprise-ontology-platform-comparison/): Five vendors shipped an enterprise ontology or semantic layer between November 2025 and August 2026. A cell-by-cell comparison of objects, relationships, actions, permissions and agent interfaces, sourced to vendor docs.
- [Context Is the Bottleneck in Enterprise AI: Every Fix Solves Only the Read Half](https://www.objectos.ai/en/blog/context-bottleneck-read-half/): Two of the largest data platforms built their June 2026 keynotes around the same claim, and it is correct. But semantic layers, catalogs and ontologies all ground what an agent reads. The write half runs on borrowed enforcement.
- [Forward Deployed Engineer vs Solutions Engineer vs Solutions Architect vs Consultant](https://www.objectos.ai/en/blog/forward-deployed-engineer-vs-solutions-architect/): Four roles that look identical in the customer's conference room and diverge on the org chart. A comparison table on outcome ownership, production code, quota, reporting line and pay — plus the one question that separates them.
- [The Forward Deployed Engineer Model: Why Copying Palantir Builds a Consultancy](https://www.objectos.ai/en/blog/forward-deployed-engineer-trap/): Four AI giants stood up forward-deployed orgs in 2026. Palantir earns roughly 11x the revenue per employee Accenture does — and the gap is not the role, it is the substrate the role writes into.
- [Ontology vs Semantic Layer vs Knowledge Graph: What Is Actually Different](https://www.objectos.ai/en/blog/ontology-vs-semantic-layer-vs-knowledge-graph/): A semantic layer defines what a number means. A knowledge graph stores what connects to what. Only an ontology carries actions and permissions. Precise definitions, a decision table, and a test for which one your agent needs.
- [What Is Ontology MCP? Turning an Enterprise Ontology Into Agent Tools](https://www.objectos.ai/en/blog/ontology-mcp-agent-tools/): Ontology MCP exposes an ontology's object types, action types and functions as MCP tools any agent can call. What Palantir shipped, what Microsoft is previewing, and the tool-surface asymmetry to plan for.
- [What Tools Do Forward-Deployed Engineers Use? An Ontology-First Open Stack](https://www.objectos.ai/en/blog/forward-deployed-engineer-tools/): What forward deployed engineers actually build across a 60–180 day deployment, the five pains that define the work, and why the 2026 copycat wave copied the role but not the substrate underneath it.
- [How Many Tokens Is a Business App? A Complete CRM Under 150k](https://www.objectos.ai/en/blog/business-app-in-16k-tokens/): A complete CRM—business logic, permissions, workflows, and UI—fits under 150k tokens of typed metadata. Business logic stays under 100k; UI adds ~50k. The bundled reference CRM is ~16k.
- [When an AI Agent Deletes Production Data: Runtime Guardrails Beat Prompts](https://www.objectos.ai/en/blog/when-ai-agent-deletes-production-database/): The Replit database incident shows a structural lesson: an agent's blast radius must be controlled by runtime permissions, approvals, and audit logs, not only by a prompt.
- [Retool vs. Governed AI App Platforms: Can You Review Business Authority?](https://www.objectos.ai/en/blog/retool-vs-ai-native-app-platform/): Retool has strong access governance, including RBAC, audit logs, SSO, and self-hosting. The harder question is whether business authority is declared as a reviewable fact.
- [Power Platform Lock-In: Dataverse, Azure, and the Self-Host Tradeoff](https://www.objectos.ai/en/blog/power-platform-lock-in-dataverse-self-host/): Power Platform is already inside the Microsoft tenant, but self-hosting, Dataverse export, AI usage pricing, and sovereignty requirements matter for long-running systems.
- [Is Lovable Safe for Production? The Access-Control Review Problem](https://www.objectos.ai/en/blog/is-lovable-safe-for-production/): Lovable can turn a sentence into a full-stack app, but production data depends on access control the accountable builder must be able to inspect, understand, and approve.
- [Airtable Omni vs. Governed AI App Platforms: Why Reviewed Diffs Beat Undo](https://www.objectos.ai/en/blog/airtable-omni-vs-governed-ai-app-platform/): Airtable Omni can build a real app from one sentence, but regulated systems of record need reviewed diffs, preventive controls, and infrastructure choices that go beyond undo.
- [AI-Written Apps: Can You Review the Diff and Merge With Confidence?](https://www.objectos.ai/en/blog/ai-wrote-your-app-dare-to-merge/): AI can generate a working app in 30 minutes. The hard part is signing off on an 8,000-line PR you did not write. Reviewability, not speed, is the new moat.
- [How to Write Agent Rules That Generate Governable Apps](https://www.objectos.ai/en/blog/give-your-agent-rules-for-governable-apps/): Most agent rule files police style, not governance. Use AGENTS.md, .cursor/rules, and an open declarative target so AI-generated apps are reviewable from day one.
- [Open vs. Closed Enterprise Ontologies: Who Owns the Business Semantic Layer?](https://www.objectos.ai/en/blog/enterprise-ontology-race-open-vs-closed/): Five platforms shipped a business semantic layer between Nov 2025 and Aug 2026, and most opened an MCP read path while keeping the definition inside. Protocol-open, definition-closed — and the ownership question got sharper.
- [Vibe Coding Technical Debt: Why AI-Built Apps Become Hard to Change](https://www.objectos.ai/en/blog/vibe-coding-technical-debt-2026/): A team's AI-built expense system ran fine for months until tax rules changed and no one dared touch its 12,000 lines of unread code. Why generating definitions beats generating code.
- [EU AI Act Audit Readiness: Can Your AI Runtime Produce Evidence?](https://www.objectos.ai/en/blog/eu-ai-act-runtime-audit/): When an auditor asks for the full record of one AI decision, model quality is not enough. Your runtime must show authorization, evidence, oversight, and audit history.
- [MCP Security for Enterprise Agents: Why Protocols Need Governed Tools](https://www.objectos.ai/en/blog/mcp-governed-tool-layer/): MCP can connect agents to tools quickly, but enterprise systems need identity, permissions, approvals, and audit behind every tool call.
- [Why AI Agent Pilots Fail Before Production: The Four Missing Layers](https://www.objectos.ai/en/blog/why-ai-agent-pilots-fail-four-layers/): A project drew applause on demo day, then was killed four months later by one question from legal. The problem was not the model; it was missing semantics, permissions, approvals, and audit.
- [AI Agent Pricing: Per-Action Billing vs. Self-Hosted Runtime Cost](https://www.objectos.ai/en/blog/enterprise-agent-true-cost/): At $0.10 per Agentforce action, a successful agent can make usage-based pricing rise quickly. Compare per-action billing with a self-hosted runtime before you scale.
- [Agentforce vs. an Open Self-Hosted Runtime: When to Choose Each](https://www.objectos.ai/en/blog/beyond-agentforce-copilot-open-runtime/): A company nearly signed with Agentforce until it found that half its data lived outside the suite. Here is when to choose a closed suite, when to choose open self-hosting, and when to use both.
- [Enterprise AI Ontology: Why the Definition and Runtime Should Be Open](https://www.objectos.ai/en/blog/ai-ontology-open-protocol/): Ontology MCP went GA in June 2026 — the vendors made the agent interface an open protocol themselves. Definitions are following. The runtime is the layer nobody opened, and that is where portability actually lives.
- [Cross-System Workflow Automation: Connector Failure Handling in a Governed Process](https://www.objectos.ai/en/blog/automation-cross-system-flows/): The moment a step leaves your runtime you stop being able to observe it. A governed cross-system flow declares what each outbound call does, designs the failure path first, and never reports a step it could not measure as zero.
- [Natural Language Workflow Changes: How to Review an AI-Edited Flow Before It Ships](https://www.objectos.ai/en/blog/automation-governed-flow-changes/): A sentence can change a business process in seconds. Whether it should is a review question. How a flow edit becomes a diff, a publish gate that refuses what it can prove wrong, and an audit row you can roll back to.
- [Automation Trigger Types: Record Changes, Schedules, Buttons, and Webhooks in One Flow](https://www.objectos.ai/en/blog/automation-trigger-model/): A flow can start from a record change, a clock, a date field, a button, or an inbound POST. Choosing the trigger is cheap. The expensive mistake is a flow that looks armed in the designer and is wired to nothing at runtime.
- [Workflow Pause and Resume: What a Long-Running Approval Needs to Survive](https://www.objectos.ai/en/blog/automation-pause-resume-approvals/): A flow that waits days for an approval has to park its state, survive a restart, and refuse the wrong caller. What durable pause and resume actually costs — and why a wait node with no deadline is the honest answer.
- [Enterprise AI Automation Engine: How a Flow Decides, Waits, and Proves What It Did](https://www.objectos.ai/en/blog/objectos-automation-engine/): Trigger-and-forget automation cannot carry a business process. An enterprise automation engine has to branch on real conditions, park for a person, resume after a restart, and leave a run record that proves what it changed.
- [Ontology Actions: How to Govern AI Agent Write Operations](https://www.objectos.ai/en/blog/objectos-action-tools/): Enterprise ontology work stops at retrieval. When an agent has to change state, write operations need one governed definition — opt-in exposure, permission parity, confirmation and audit — not a second tool path beside your UI.
- [Where AI Agent Permissions Are Enforced: Row-Level Security, Field Masking, and Tool Gates](https://www.objectos.ai/en/blog/objectos-agent-permission-boundaries/): Everyone agrees an AI agent should respect permissions. The real question is where the check runs. Filtering the model's output is too late — enforcement belongs in the query, the field, and the tool gate.
- [Metadata, Not Code Generation: What Makes AI-Built Apps Governable](https://www.objectos.ai/en/blog/metadata-not-code-generation/): Code generation can speed up prototypes, but enterprise applications need a metadata runtime where objects, fields, views, permissions, workflows, actions, and agent tools are governed together.
- [From a Sentence to a Governable App: How AI Generates App Metadata](https://www.objectos.ai/en/blog/natural-language-to-app-metadata/): The important part of AI Builder is not turning one sentence into pages, but decomposing a business request into objects, fields, views, workflows, permissions, automation, and agent tools.
- [Airtable-Style AI App Builder: Build by Table, Change by Chat](https://www.objectos.ai/en/blog/airtable-style-ai-builder/): A strong AI app builder combines table-based app building with natural-language iteration, while keeping objects, fields, views, permissions, and automation visible.
- [Edit Business Systems by Conversation: Add Fields and Change Flows](https://www.objectos.ai/en/blog/conversational-app-iteration/): The real value of an AI builder is continuous conversational iteration: fields, workflows, views, permissions, and automation evolve through reviewable metadata changes.
- [AI Ticket Hub: Build a Support System That Actually Reads the Customer's Problem](https://www.objectos.ai/en/blog/ai-ticket-hub/): A support system should do more than queue issues. With metadata for cases, messages, SLA, knowledge, permissions, and agent tools, AI can understand customer problems and move work forward safely.
- [AI Sales Assistant: How to Update CRM Records and Suggest Next Steps](https://www.objectos.ai/en/blog/ai-sales-assistant/): An AI sales assistant is not just auto-fill for CRM. Natural language can generate accounts, contacts, opportunities, activities, tasks, and agent tools so sellers work through conversation.
- [AI Project Management Assistant: Surfacing the Risk Hidden in Status Updates](https://www.objectos.ai/en/blog/ai-project-risk-assistant/): An AI project assistant is not another board. It models projects, tasks, meetings, risks, changes, and action plans so AI can detect delays and blockers from everyday updates.
- [AI Procurement Risk: How to Spot Supplier Risk Before Approval](https://www.objectos.ai/en/blog/ai-procurement-risk/): An AI procurement decision app should not hide behind one supplier score. It should connect qualifications, quotes, contracts, orders, delivery, quality, and risk evidence into a conversational decision layer.
- [AI Expense Audit: Build a Finance App That Understands Policy, Not Just OCR](https://www.objectos.ai/en/blog/ai-expense-audit/): AI expense review is not only invoice recognition. It should model policies, budgets, projects, approvals, anomaly patterns, and audit records so finance can explain every recommendation.
- [AI Employee Service Center: How to Move Beyond HR, IT, and Admin Tickets](https://www.objectos.ai/en/blog/ai-employee-service-center/): An AI employee service center is not a chat wrapper over HR, IT, and admin tickets. It models service catalogs, knowledge, requests, approvals, and governed agent actions.
- [AI Contract Review: Build an App That Flags Clause and Obligation Risk First](https://www.objectos.ai/en/blog/ai-contract-risk/): The value of an AI contract app is not summarization. It is turning contract types, clauses, obligations, risk rules, approvals, and audit into metadata that legal and business teams can use together.
- [AI Content Workbench: From Ideas to Publishing and Retrospectives](https://www.objectos.ai/en/blog/ai-content-workbench/): Content teams need more than a writing box. Natural language can build topics, sources, briefs, drafts, reviews, publishing, and metrics so AI participates in the full content workflow.
- [AI Compliance and Internal Controls: Stop Checking Policies by Hand](https://www.objectos.ai/en/blog/ai-compliance-control/): An AI internal control app is not only policy Q&A. It turns policy clauses, controls, evidence, gaps, remediation, and audit records into a closed-loop compliance workflow.
- [AI Agent Workbench: How Agents Execute Tasks Inside Business Systems](https://www.objectos.ai/en/blog/ai-agent-workbench/): Enterprise agents must do more than chat. They need business objects, tools, permissions, approvals, and audit boundaries so natural-language intent can become controlled execution.
- [Self-Hosted AI Application Platforms: Why the Runtime Belongs to You](https://www.objectos.ai/en/blog/self-hosted-ai-app-platform/): Once AI reads business data, triggers workflows, generates applications, and calls tools, enterprises need control over the runtime that governs objects, permissions, tools, approvals, and audit evidence.
- [From Requirement to Running App: How AI Generates Reviewable Metadata](https://www.objectos.ai/en/blog/from-requirement-to-app/): A concrete equipment repair scenario shows how AI Builder turns one request into objects, fields, relationships, views, permissions, actions, workflows, APIs, and agent tools.
- [How AI Agents Stay Inside Enterprise Permission Boundaries](https://www.objectos.ai/en/blog/ai-agent-business-data-security-boundaries/): Enterprise teams do not need AI agents to become unrestricted administrators. They need agents that act as controlled users, inherit permissions, route risky actions for approval, and leave an audit trail.
- [AI for Legacy Manufacturing Systems: Start With Reports and Work Orders](https://www.objectos.ai/en/blog/manufacturing-legacy-systems-ai/): Manufacturing systems are hard to replace. A practical AI path connects existing systems and starts with reports, work orders, and exception analysis.
- [Low-Code vs. AI-Native App Platforms: Where Complex Business Breaks](https://www.objectos.ai/en/blog/low-code-vs-ai-native-app-platform/): Low-code helps teams build pages and workflows faster, but complex business systems depend on objects, permissions, integrations, change control, and maintainability.
- [AI for CRM: How Agents Read Customer Data Without Bypassing Permissions](https://www.objectos.ai/en/blog/crm-ai-understands-customers/): Most CRMs already hold customer, opportunity, contact, and activity history. The useful path is to let AI understand those business objects under existing permissions.
- [Custom Software Technical Debt: Why Internal Systems Become Unmaintainable](https://www.objectos.ai/en/blog/why-custom-systems-die/): A five-year ledger for one $45,000 custom system: the toll after the build invoice reached $81,100, or 1.8x the purchase price. Plus a six-question health check for the internal system you cannot replace.
- [Add AI to Existing Systems Without Migration: Connect Your Database](https://www.objectos.ai/en/blog/extend-existing-systems-with-ai/): Connect ObjectOS to the database you already run, let a coding agent model the tables as objects, and put AI on real data under your permissions, on your servers, with the original system untouched.

## Simplified Chinese Articles

- [FDE(前沿部署工程师)用什么工具？一套本体优先的开源技术栈](https://www.objectos.ai/zh-Hans/blog/forward-deployed-engineer-tools/): FDE 在一次 60–180 天的部署里真正写下什么:接入适配器、实体解析、权限映射、最初的几条工作流。加上定义这份工作的五个痛点,以及 2026 年的模仿潮为什么只抄走了岗位、没抄走底下的基质。
- [一个业务应用到底有多少 token？完整 CRM 全应用不到 150k](https://www.objectos.ai/zh-Hans/blog/business-app-in-16k-tokens/): 完整 CRM 的数据模型、流程、权限与界面合计不到 150k token：业务逻辑不到 100k，UI 约 50k；随包参考 CRM 仍约 16k。能整体装进智能体上下文的软件，维护方式完全不同。
- [AI 智能体删除生产数据：为什么运行时护栏比提示词可靠](https://www.objectos.ai/zh-Hans/blog/when-ai-agent-deletes-production-database/): 公开记录中的 Replit 事故提醒我们：智能体的影响半径不能只靠提示词收窄。生产数据、破坏性操作和恢复证据，都需要由运行时权限、审批和审计来约束。
- [Retool 与受治理 AI 应用平台：能否审查业务权限](https://www.objectos.ai/zh-Hans/blog/retool-vs-ai-native-app-platform/): Retool 的 RBAC、审计日志、SSO 和自托管能力很强。真正要比较的是业务权限层：退款、审批、写入动作如果散落在 JavaScript 绑定里，AI 改动就很难被业务负责人用 diff 审查。
- [Power Platform 锁定：Dataverse、Azure 与自托管取舍](https://www.objectos.ai/zh-Hans/blog/power-platform-lock-in-dataverse-self-host/): Power Platform 的优势是真实的：身份、Teams、Dynamics 和账单都在同一个租户里。但若你关心主权、规模化成本或 AI 改动审查，Dataverse 和 Azure 运行时就是必须提前算清的边界。
- [Lovable 上生产安全吗：访问控制审查问题](https://www.objectos.ai/zh-Hans/blog/is-lovable-safe-for-production/): Lovable 很适合快速原型，但生产系统的问题不是能不能跑，而是谁能审查访问控制。RLS、前端过滤和安全扫描都重要；真正的边界必须在服务端可见、可强制、可签字。
- [Airtable Omni 与受治理 AI 应用平台：为什么审阅 diff 比撤销更重要](https://www.objectos.ai/zh-Hans/blog/airtable-omni-vs-governed-ai-app-platform/): Airtable Omni 把自然语言和表格式应用结合得很强。记录系统真正要比较的，不是能不能生成应用，而是 AI 改动权限、字段和流程时，是否能在上线前形成可审阅的 diff。
- [AI 写完应用之后：你敢审查 diff 并点 Merge 吗？](https://www.objectos.ai/zh-Hans/blog/ai-wrote-your-app-dare-to-merge/): AI 可以很快生成能跑的应用，CI 也可能全绿。真正的问题是：那份几千行、没人完整理解的 PR，谁敢负责合并？当写代码被自动化，瓶颈就从“写”转向“审查与签字”。
- [Agent 规则文件怎么写：让 AI 生成可治理应用](https://www.objectos.ai/zh-Hans/blog/give-your-agent-rules-for-governable-apps/): 编码 agent 的 AGENTS.md、.cursor/rules 或 CLAUDE.md 不该只管代码风格。把权限、审批、审计和目标元数据格式写进去，AI 生成的应用才更容易被审查和签字。
- [开放与封闭企业本体：谁拥有业务语义层](https://www.objectos.ai/zh-Hans/blog/enterprise-ontology-race-open-vs-closed/): 2025 年 11 月到 2026 年 8 月，五家平台各自交付了业务语义层，而且大多把 MCP 读取通道开放了出来，定义本身却仍留在平台里。协议开放，定义封闭——归属之争因此更尖锐了。
- [Vibe Coding 技术债：为什么 AI 生成的应用后来难改](https://www.objectos.ai/zh-Hans/blog/vibe-coding-technical-debt-2026/): AI 生成代码能让原型很快上线，但长期系统的问题在半年后出现：没人完整读过那一万多行实现，也没人能解释当初的业务取舍。企业应用需要生成可审查的定义，而不是难维护的黑箱代码。
- [EU AI Act 审计准备：你的 AI 运行时能交出证据吗](https://www.objectos.ai/zh-Hans/blog/eu-ai-act-runtime-audit/): AI Act 的多数规则按官方时间线将在 2026 年 8 月 2 日适用。审计真正要看的不是模型多强，而是运行时能否交出谁授权、动了什么、证据在哪。
- [MCP 安全：为什么协议还需要受治理的工具层](https://www.objectos.ai/zh-Hans/blog/mcp-governed-tool-layer/): MCP 和 A2A 让 agent 连接工具与其他 agent 变得更容易，但连接不等于授权。企业缺的不是再包一层接口，而是每次调用都带身份、强制权限、留下审计的工具层。
- [为什么 AI Agent 试点进不了生产：缺的是四层运行基础](https://www.objectos.ai/zh-Hans/blog/why-ai-agent-pilots-fail-four-layers/): 一个 agent 演示可以很精彩，生产评审却只问一件事：你怎么证明它不会越权、会等审批、能交出审计证据？试点失败通常不是模型不够强，而是缺语义、权限、审批和审计四层。
- [AI Agent 定价：按动作计费与自托管运行时成本](https://www.objectos.ai/zh-Hans/blog/enterprise-agent-true-cost/): 按动作或按 token 计费看起来灵活，但 agent 越自主，中间工具调用越多。真正的成本账要同时看用量曲线、数据出域、平台锁定，以及什么时候自托管才划算。
- [Agentforce、Copilot Studio 之外：何时选择开放自托管运行时](https://www.objectos.ai/zh-Hans/blog/beyond-agentforce-copilot-open-runtime/): Agentforce、Copilot Studio、ServiceNow AI Agents 在各自生态内都很强。问题是你的数据、流程和权限是否也在同一个生态内；若不是，开放自托管运行时或混合架构可能更稳。
- [企业 AI Ontology：为什么业务定义与运行时都应该开放](https://www.objectos.ai/zh-Hans/blog/ai-ontology-open-protocol/): 2026 年 6 月 Ontology MCP 正式可用：厂商自己把 agent 接口交给了开放协议，定义层也在跟进。唯独运行时没人打开——而可移植性恰恰住在那一层。
- [跨系统自动化：连接器和 Webhook 如何进入受治理流程](https://www.objectos.ai/zh-Hans/blog/automation-cross-system-flows/): CRM、ERP、合同、财务和外部服务都在流程里。可靠的自动化引擎不是多接几个 API，而是把外部调用、失败补救和审计放进同一条业务流程。
- [自然语言改流程：自动化引擎如何治理变更](https://www.objectos.ai/zh-Hans/blog/automation-governed-flow-changes/): 自然语言可以降低流程修改门槛，但不能让流程直接上线。可靠的自动化引擎要把每次变更变成可审查、可校验、可发布、可回滚的流程元数据。
- [自动化触发模型：数据变化、定时、按钮和 API 如何进入同一流程](https://www.objectos.ai/zh-Hans/blog/automation-trigger-model/): 流程可以由记录变化、定时计划、人工按钮或外部系统的入站调用触发；ObjectStack 的 Webhook 指向相反方向，是出站推送。成熟的自动化引擎要统一入口后的业务规则，避免同一流程在多个地方重复实现。
- [审批与暂停恢复：自动化引擎为什么必须会等待](https://www.objectos.ai/zh-Hans/blog/automation-pause-resume-approvals/): 企业流程经常要等人审批、等用户补材料、等时间到达或等外部结果。自动化引擎只有支持暂停和恢复，才能把这些等待放进同一条完整流程。
- [AI 自动化流程：如何判断、等待并留下证据](https://www.objectos.ai/zh-Hans/blog/objectos-automation-engine/): 企业需要的自动化不是简单触发器，而是能把业务规则变成可审批、可等待、可恢复、可审计的流程元数据。ObjectOS 让 AI 生成的流程进入业务运行时。
- [AI 如何触发业务动作：Action 元数据如何保证受控执行](https://www.objectos.ai/zh-Hans/blog/objectos-action-tools/): AI agent 的价值不只是回答问题，而是帮助用户更新记录、创建任务、发起审批和推动流程。ObjectOS 用 Action 元数据把按钮、流程和审批开放给 AI，同时保留权限、确认和审计。
- [AI Agent 权限检查跑在哪一层：查询下推、字段脱敏与工具闸门](https://www.objectos.ai/zh-Hans/blog/objectos-agent-permission-boundaries/): 该不该守权限已经没有争议；决定这道边界真假的是检查跑在哪一层。数据进入模型上下文之后再过滤，等于没过滤——那是纸面权限。本文拆开查询、字段、工具闸门三个执行点，以及平台明确不兜底的两处。
- [元数据，不是代码生成：AI 应用为什么可治理](https://www.objectos.ai/zh-Hans/blog/metadata-not-code-generation/): 代码生成能让原型变快，但企业应用真正需要的是对象、字段、关系、视图、权限、流程、动作和 agent 工具共同受控的元数据运行时。
- [从自然语言到应用元数据：AI Builder 如何生成对象和权限](https://www.objectos.ai/zh-Hans/blog/natural-language-to-app-metadata/): AI Builder 真正重要的不是把一句话变成页面，而是把业务需求拆成对象、字段、视图、流程、权限、自动化和 agent 工具。
- [Airtable 式 AI Builder：用表格理解应用，用对话修改应用](https://www.objectos.ai/zh-Hans/blog/airtable-style-ai-builder/): 最好的 AI Builder 把表格式搭建、对话式修改和受治理的元数据结合起来：对象、字段、视图、权限和自动化都可见，也都能被审查。
- [对话式应用迭代：加字段、改流程、生成视图和自动化](https://www.objectos.ai/zh-Hans/blog/conversational-app-iteration/): AI Builder 的真正价值不是“聊一句就改”，而是把字段、流程、视图、权限和自动化都落到可审查、可回滚的元数据层。
- [AI 工单中枢：让客服系统读懂客户问题](https://www.objectos.ai/zh-Hans/blog/ai-ticket-hub/): 客服工单不应该只负责排队。把对象、队列、SLA、知识库和受控工具做成元数据后，AI 才能在权限边界内理解问题、推荐回复并推动流转。
- [AI 销售助理：如何更新 CRM 并建议下一步](https://www.objectos.ai/zh-Hans/blog/ai-sales-assistant/): AI 销售助理不只是自动填表，而是把客户、联系人、商机、跟进和任务做成可治理的元数据，让销售用对话推进商机，同时保留权限和审计。
- [AI 项目管理助手：从进度更新里发现风险](https://www.objectos.ai/zh-Hans/blog/ai-project-risk-assistant/): AI 项目助手的价值不是再做一个看板，而是把项目、任务、会议、风险、变更和行动计划做成对象，从日常更新中识别延期和阻塞。
- [AI 采购风险：下单前看见供应商风险](https://www.objectos.ai/zh-Hans/blog/ai-procurement-risk/): AI 采购应用不只是给供应商打分，而是把供应商、资质、报价、合同、履约和风险做成元数据，让采购在下单前看见依据。
- [AI 报销审核：理解政策，而不只是识别发票](https://www.objectos.ai/zh-Hans/blog/ai-expense-audit/): AI 报销审核不止识别发票，而是把费用政策、预算、项目、审批、异常模式和审计记录做成元数据，让财务能解释和处理风险。
- [AI 员工服务中心：从 HR/IT 工单到可执行服务](https://www.objectos.ai/zh-Hans/blog/ai-employee-service-center/): AI 企业服务中心不是把 HR、IT、行政工单换成聊天框，而是把服务目录、知识库、申请对象、审批流和受控动作做成可执行服务。
- [AI 合同审查：先标风险，再让法务签字](https://www.objectos.ai/zh-Hans/blog/ai-contract-risk/): AI 合同应用不只是总结合同，而是把合同类型、条款、义务、风险规则、审批和审计做成元数据，让 AI 标风险、法务确认责任。
- [AI 内容工作台：从选题到发布与复盘](https://www.objectos.ai/zh-Hans/blog/ai-content-workbench/): 内容团队需要的不是孤立写作框，而是把选题、素材、草稿、审核、发布和复盘做成对象，让 AI 参与完整内容运营流程。
- [AI 内控检查：把制度变成可追溯控制](https://www.objectos.ai/zh-Hans/blog/ai-compliance-control/): AI 内控应用不是制度问答，而是把制度条款、控制点、证据、缺口、整改和审计做成对象；AI 发现缺口，人确认责任，运行时保留证据链。
- [AI Agent 工作台：让 agent 在业务系统内受控执行](https://www.objectos.ai/zh-Hans/blog/ai-agent-workbench/): 企业 agent 不能只是会聊天，而要能在业务对象、工具、权限、审批和审计边界内执行任务。工作台的关键是受控执行，而不是万能权限。
- [自托管 AI 应用平台：为什么运行时属于你](https://www.objectos.ai/zh-Hans/blog/self-hosted-ai-app-platform/): 当 AI 开始读取业务数据、触发流程、生成应用和调用工具，企业真正要控制的不只是模型，而是承载对象、权限、工具、审批和审计的运行时。
- [从需求到可审查应用：AI 如何生成 ObjectStack 元数据](https://www.objectos.ai/zh-Hans/blog/from-requirement-to-app/): 用设备报修场景拆开 AI Builder 的生成过程：对象、字段、关系、视图、权限、动作、流程、API 和 agent 工具如何由同一份元数据驱动。
- [AI Agent 数据安全边界：如何在企业权限内工作](https://www.objectos.ai/zh-Hans/blog/ai-agent-business-data-security-boundaries/): 企业不是不想让 AI agent 使用业务数据，而是不允许它绕过身份、权限、审批和审计。真正可上线的 agent，必须像一个受控用户，而不是影子管理员。
- [制造业既有系统怎么接 AI：先从报表和工单开始](https://www.objectos.ai/zh-Hans/blog/manufacturing-legacy-systems-ai/): 制造业系统链路复杂，ERP、MES、WMS、设备台账和工单系统都不能轻易替换。更务实的 AI 路线，是先连接现有系统，从报表、工单和异常分析切入。
- [低代码 vs AI 原生应用平台：复杂业务卡在哪里](https://www.objectos.ai/zh-Hans/blog/low-code-vs-ai-native-app-platform/): 低代码解决的是更快搭页面和流程；复杂业务真正卡住的是对象、权限、集成、变更和可维护性。AI 原生平台要把这些变成可审查的运行时元数据。
- [CRM AI：让 agent 在权限内读取客户和商机](https://www.objectos.ai/zh-Hans/blog/crm-ai-understands-customers/): 很多公司的 CRM 里已有客户、商机、联系人和跟进记录。真正有价值的做法不是导出数据问一次，而是让 agent 在权限之下读懂这些业务对象。
- [定制系统技术债：为什么半年后没人敢改](https://www.objectos.ai/zh-Hans/blog/why-custom-systems-die/): 很多内部系统不是越用越顺，而是越用越僵。根因往往不在程序员，而在业务规则被埋进代码里，后续既难审查，也难让 AI 安全修改。
- [给现有系统加 AI：连接数据库，而不是先迁移](https://www.objectos.ai/zh-Hans/blog/extend-existing-systems-with-ai/): 把 ObjectOS 连到已经运行的数据库，让 agent 把关键数据表建模为对象，再在你的权限和服务器边界内叠加 AI 能力；原系统继续运行，AI 走受控对象层。

## Policies

- [Terms](https://www.objectos.ai/en/terms/)
- [Privacy](https://www.objectos.ai/en/privacy/)