From 42648e1011fd7109f2606e78a0808a619079c348 Mon Sep 17 00:00:00 2001 From: "objectstack-fleet[bot]" Date: Fri, 16 Oct 2026 07:01:14 +0000 Subject: [PATCH 1/4] =?UTF-8?q?content(positioning):=20speak=20the=20ontol?= =?UTF-8?q?ogy=20below=20the=20hero=20=E2=80=94=20capability=20pages,=20ho?= =?UTF-8?q?me,=20glossary,=20llms.txt,=20the=20AI-native=20cluster?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Capability pages name the ontology and the promise each already proves (mcp: Agent-operable; data-modeling: the core; app-ui: projections; permissions: the shared fence; agent-developer: AI-writable). Home's three below-the-fold strings and terms.ts descriptions leave "AI-native"; the media-note title now reads T2's first sentence from positioning. Glossary: `ontology` leads with the executable business ontology and its four boundaries, `ontology-projection` is new, `metadata-driven-development` gains a lineage note. llms.txt Core Definitions: "Metadata driven development with an AI as the author" gives way to "Executable business ontology". The `ai-native-app-platform` cluster is rewritten to the ontology framing, slug and URL unchanged. Co-Authored-By: Claude Claude-Session: https://claude.ai/code/session_017GeNDQH7E5S2rX8ajVAPxv --- .../en/metadata-driven-development.ts | 2 + content/glossary/en/ontology-projection.ts | 29 ++++++++++++ content/glossary/en/ontology.ts | 18 ++++---- .../zh-Hans/metadata-driven-development.ts | 2 + .../glossary/zh-Hans/ontology-projection.ts | 29 ++++++++++++ content/glossary/zh-Hans/ontology.ts | 18 ++++---- content/pages/en/agent-developer.ts | 6 +-- content/pages/en/app-ui.ts | 8 ++-- content/pages/en/data-modeling.ts | 6 +-- content/pages/en/mcp.ts | 4 +- content/pages/en/permissions.ts | 4 +- content/pages/zh-Hans/agent-developer.ts | 6 +-- content/pages/zh-Hans/app-ui.ts | 8 ++-- content/pages/zh-Hans/data-modeling.ts | 6 +-- content/pages/zh-Hans/mcp.ts | 4 +- content/pages/zh-Hans/permissions.ts | 4 +- src/lib/cluster-i18n.ts | 24 ++++++---- src/lib/clusters.ts | 42 +++++++++-------- src/lib/home.ts | 46 ++++++++++--------- src/lib/terms.ts | 35 +++++++------- src/pages/llms.txt.ts | 4 +- 21 files changed, 190 insertions(+), 115 deletions(-) create mode 100644 content/glossary/en/ontology-projection.ts create mode 100644 content/glossary/zh-Hans/ontology-projection.ts diff --git a/content/glossary/en/metadata-driven-development.ts b/content/glossary/en/metadata-driven-development.ts index 8e499aa..312d578 100644 --- a/content/glossary/en/metadata-driven-development.ts +++ b/content/glossary/en/metadata-driven-development.ts @@ -9,6 +9,7 @@ const term = { definition: '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.', explanation: [ + 'A note on lineage: until October 2026 this was the term that defined the product on this site. The product is now defined by the executable business ontology — see the Ontology entry in this glossary, and the related terms below. Metadata-driven development remains the method by which that ontology is written: the definition is typed metadata, and when an AI agent writes it, the metadata is what a person reviews. The page stays because it is linked to and searched for; the definition below is unchanged.', 'The idea is not new, and pretending otherwise is the fastest way to be misread. Enterprise platforms have been describing applications as declarations rather than code since the mid-2000s, and the vocabulary comes from that lineage: objects instead of tables, permission sets instead of authorization middleware, flows instead of job scripts. What that generation established is worth keeping — a field added to a definition appears in the API, the list view, the detail form, the export, and the permission model at once, because all of them are derived from the same declaration rather than kept in sync by hand.', 'What has changed is who writes the declaration. When a human authored it through a point-and-click console, the payoff was speed and consistency, and the format could afford to be a proprietary XML dialect nobody read directly. When an AI agent authors it, the format itself becomes the constraint that decides whether the output is trustworthy: a complete business application expressed as metadata is a few thousand lines rather than a few hundred thousand, so an agent can hold the whole system in one context window instead of sampling a codebase it cannot see the edges of, and the human reviewing the change reads a diff of declarations — which fields moved, which permission changed, which step now requires approval — rather than auditing a generated controller, template, migration, and test.', 'Stated bare, the term collapses into the low-code reading and loses the argument, so it is worth being precise about the difference. A drag-and-drop builder optimizes for a person who does not want to write code; metadata-driven development in this sense optimizes for a reviewer who did not write the code and must sign off on it anyway. Those produce different formats. The first can hide the definition behind a UI, because the UI is the interface. The second cannot: the definition has to be a readable, version-controlled, diffable file, because a diff is the review surface and an agent — not a form — is the thing writing it.', @@ -20,6 +21,7 @@ const term = { 'declarative application development', ], relatedTerms: [ + 'ontology', 'application-metadata', 'typed-metadata', 'application-definition-vs-runtime', diff --git a/content/glossary/en/ontology-projection.ts b/content/glossary/en/ontology-projection.ts new file mode 100644 index 0000000..27d67dc --- /dev/null +++ b/content/glossary/en/ontology-projection.ts @@ -0,0 +1,29 @@ +import type { GlossaryTerm } from '../../../src/glossary/types'; + +const term = { + slug: 'ontology-projection', + term: 'Ontology projection', + title: 'Ontology Projection: Views, Dashboards, Apps, and Translations Derived from the Ontology', + description: + 'An ontology projection is a view, dashboard, app, or translation derived from an executable business ontology — authored as metadata and validated by the same gate, but not part of the ontology, so the core changes and the projections follow.', + definition: + 'An ontology projection is a view, dashboard, app, or translation derived from an executable business ontology — authored as metadata and validated by the same gate, but not part of the ontology itself, so that changing the core changes the projection while removing a projection leaves the business it showed unchanged.', + explanation: [ + 'The ontology is the definition of the business the runtime runs: objects and fields, relations, actions, permissions, flows, and agent and tool definitions. Everything a person looks at is a projection of it. A list view projects an object\'s fields and permissions onto a grid; a dashboard projects queries over objects onto charts; an app groups objects, views, and actions into a navigable product; a translation projects every label into a locale. The projection is real metadata — authored, typed, validated, and reviewed like the rest — but it describes how the business is shown, not what the business is.', + 'The test for telling core from projection is what happens when you delete it. Remove a kanban view and the cases, their owners, and who may edit them are exactly as they were; remove the permission that scoped the kanban and the business has changed. That is why the distinction bounds what an agent must hold to reason about a business: the core, not every screen. It also decides what a reviewer reads: a diff that touches only projections changes presentation, and a diff that touches the core changes authority.', + 'Two things are not projections, though they are often mistaken for them. Actions are part of the ontology: they define what may be done to a record and under which conditions, and an agent calls them as tools. Permissions are part of the ontology: a view is shaped by them; it does not define them. Code is not a projection either — hooks, action bodies, CEL expressions, and constrained JSX run inside the runtime, under the same permission and audit fence as everything derived from the ontology.', + ], + alsoKnownAs: ['projection', 'view projection', 'projection of the ontology'], + relatedTerms: [ + 'ontology', + 'application-metadata', + 'typed-metadata', + 'definition-layer', + 'reviewable-diff', + 'object-type-and-action-type', + ], + articleSlugs: ['what-does-the-ontology-is-the-software-mean'], + pageSlugs: ['app-ui'], +} satisfies GlossaryTerm; + +export default term; diff --git a/content/glossary/en/ontology.ts b/content/glossary/en/ontology.ts index 6f3ab5a..0b352a3 100644 --- a/content/glossary/en/ontology.ts +++ b/content/glossary/en/ontology.ts @@ -3,19 +3,20 @@ import type { GlossaryTerm } from '../../../src/glossary/types'; const term = { slug: 'ontology', term: 'Ontology', - title: 'Ontology in Enterprise Software: Definition, and Who Owns Yours', + title: 'Ontology in Enterprise Software: The Executable Business Ontology, and Who Owns Yours', description: - 'An ontology is a formal model of a business domain — its classes, properties, and relationships — expressed so software and AI agents can reason about the business instead of about raw tables.', + 'An executable business ontology is the definition of a business that a runtime runs — objects and fields, relations, actions, permissions, flows, and agent and tool definitions — validated, not reasoned over.', definition: - '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.', + 'An ontology, in the sense ObjectStack uses, is an executable business ontology: the definition of a business — its objects and fields, relations, actions, permissions, flows, and agent and tool definitions — written as typed metadata that a runtime validates and then runs, so that software and AI agents operate the business through that one definition rather than through raw tables.', explanation: [ - 'The word comes from philosophy and arrives in enterprise software through knowledge engineering, but the working definition is narrow and useful: an ontology names the types (customer, work order, device), the properties each type carries, and the links between them, once, for the whole organization. That is what separates it from a database schema. A schema describes how one application stores its rows; an ontology describes what the business means by "customer" in a way that a dozen systems, a reporting tool, and a model can all resolve the same way. Palantir Foundry is what most people picture in 2026, and its modelling quality is genuinely high; Microsoft Fabric IQ and Google\'s enterprise knowledge graph are moving into the same layer.', + 'The ontology is the software. In ObjectStack the ontology is not a layer inside a hosted platform: it is the application\'s own definition — objects and fields, relations, actions, permissions, flows, and agent and tool definitions — and the runtime runs it, deriving the database, the REST API, the screens, and the MCP tools from it and enforcing permissions and audit on every call. Four boundaries come with the word. It is executable, not a knowledge-representation ontology: no inheritance, no axioms, no reasoner — the definition is validated, then run. It is not a semantic layer over your existing systems: it is the system, and federating an external datasource is read-only by default and early. Views, dashboards, apps, and translations are projections of the ontology, not part of it. And code does not disappear: it moves into the runtime, as hooks, action bodies, CEL, and constrained JSX.', + 'The word comes from philosophy and arrives in enterprise software through knowledge engineering, where it means a formal model of a domain — its classes, properties, and relationships — that software can reason about. That working sense is narrow and useful: an ontology names the types (customer, work order, device), the properties each type carries, and the links between them, once, for the whole organization, which is what separates it from a database schema. A schema describes how one application stores its rows; an ontology describes what the business means by "customer" in a way that a dozen systems, a reporting tool, and a model can all resolve the same way. Palantir Foundry is what most people picture in 2026, and its modelling quality is genuinely high; Microsoft Fabric IQ and Google\'s enterprise knowledge graph are moving into the same layer.', 'Most ontology work stops one step short of where the risk begins. A retrieval-grade ontology is a read model: it makes an agent articulate about the business and says nothing about what happens when the agent has to change something. The capability that completes it is the declared, permission-checked write operation — the action — together with the permission and audit rules attached to the same definition. Palantir deserves credit for funnelling writes through governed actions for years; the open question was never whether that design is right.', - 'The open question is who holds the file. In ObjectStack the ontology is not a layer inside a hosted platform: it is the application\'s own definition — its objects and fields, relations, actions, permissions, flows, and agent and tool definitions — and the runtime runs it. That definition is your business ontology: open, versioned, and yours, in your own repository, not code scattered across a framework and not a graph held inside a vendor\'s system. Views, dashboards, apps, and translations are projections of it, not part of it; code does not disappear, it moves into the runtime as hooks, action bodies, CEL, and constrained JSX. A definition you can read, diff, and move to another host is a different asset from an equally good definition that lives inside a vendor\'s engine and migrates by rebuild. The slogan this reduces to is the one the ObjectStack README opens with: The ontology is the software.', - 'The boundary matters as much as the claim. ObjectStack\'s ontology is executable, not a knowledge-representation ontology: no inheritance, no axioms, no reasoner — it is validated, then run. It is not a semantic layer over your existing systems either; federating an external datasource is read-only by default and early. And an ontology does not make an AI agent correct: modelling a business well remains slow, contested, human work that no format shortcuts. What the format decides is narrower — whether the result is small enough for an agent to hold whole, strict enough to reject the agent\'s mistakes at authoring time, and portable enough to survive the platform it was first written on.', + 'The open question is who holds the file. In ObjectStack the definition is your business ontology: open, versioned, and yours, in your own repository, not code scattered across a framework and not a graph held inside a vendor\'s system. A definition you can read, diff, and move to another host is a different asset from an equally good definition that lives inside a vendor\'s engine and migrates by rebuild. An ontology does not make an AI agent correct: modelling a business well remains slow, contested, human work that no format shortcuts. What the format decides is narrower — whether the result is small enough for an agent to hold whole, strict enough to reject the agent\'s mistakes at authoring time, and portable enough to survive the platform it was first written on.', ], - alsoKnownAs: ['enterprise ontology', 'business ontology', 'domain ontology'], + alsoKnownAs: ['executable business ontology', 'business ontology', 'enterprise ontology', 'domain ontology'], relatedTerms: [ + 'ontology-projection', 'semantic-layer', 'knowledge-graph', 'object-type-and-action-type', @@ -25,13 +26,14 @@ const term = { 'governed-runtime', ], articleSlugs: [ + 'what-does-the-ontology-is-the-software-mean', 'ai-ontology-open-protocol', 'enterprise-ontology-race-open-vs-closed', 'ontology-vs-semantic-layer-vs-knowledge-graph', 'enterprise-ontology-platform-comparison', 'objectos-action-tools', ], - pageSlugs: ['data-modeling', 'platform', 'ai'], + pageSlugs: ['data-modeling', 'app-ui', 'permissions', 'mcp', 'agent-developer', 'platform', 'ai'], } satisfies GlossaryTerm; export default term; diff --git a/content/glossary/zh-Hans/metadata-driven-development.ts b/content/glossary/zh-Hans/metadata-driven-development.ts index 732c97d..98e29bb 100644 --- a/content/glossary/zh-Hans/metadata-driven-development.ts +++ b/content/glossary/zh-Hans/metadata-driven-development.ts @@ -9,6 +9,7 @@ const term = { definition: '元数据驱动开发把一个应用的对象、字段、权限、流程、动作和 API 声明为类型化元数据、交由运行时直接执行，而不是去写实现这些东西的代码——当作者变成 AI Agent 之后，这个区别开始起决定作用：声明足够小，人能真正读完并签字，而且真正在执行规则的是运行时，不是生成出来的那堆代码。', explanation: [ + '沿革说明：在 2026 年 10 月之前，本站用这个词来定义产品。现在定义产品的是可执行的业务本体——见本术语表的「本体（Ontology）」词条，以及下方的相关术语。元数据驱动开发仍然是写出那份本体的方法：定义是类型化元数据，而当作者是 AI Agent 时，人审阅的正是这份元数据。这一页保留下来，是因为它已有外部链接和搜索流量；下面的定义未变。', '这个想法并不新，装作它很新是最快被误读的方式。企业级平台从 2000 年代中期就开始用「声明而非代码」来描述应用，今天这套词汇正是从那条脉络来的：用对象而不是表，用权限集而不是鉴权中间件，用流程而不是定时脚本。那一代人立住的东西值得保留——在定义里加一个字段，API、列表视图、详情表单、导出和权限模型会同时出现它，因为这些都是从同一条声明推导出来的，而不是靠人手工保持一致。', '真正变了的，是谁在写这份声明。当声明由人在可视化控制台里点出来时，收益是速度和一致性，格式本身可以是一种没人直接阅读的私有 XML 方言。当声明由 AI Agent 编写时，格式本身就变成了决定产出可不可信的约束：一个完整业务应用用元数据表达是几千行而不是几十万行，Agent 可以在一个上下文窗口里装下整个系统，而不是对着一个看不到边界的代码库抽样阅读；而审阅这次改动的人读到的是一份声明的 diff——哪个字段动了、哪条权限变了、哪一步现在需要审批——而不是去审计生成出来的控制器、模板、迁移脚本和测试。', '这个词一旦裸着说出来，就会塌回低代码的那种读法，并且直接输掉论证，所以差别值得说清楚。拖拽式搭建器优化的是「不想写代码的人」；这里说的元数据驱动开发优化的是「不是我写的、但要我签字的审阅者」。这两件事会长出不同的格式。前者可以把定义藏在界面背后，因为界面就是入口。后者不行：定义必须是一份可读、进版本库、能 diff 的文件——因为 diff 就是审阅面，而写它的是 Agent，不是一张表单。', @@ -16,6 +17,7 @@ const term = { ], alsoKnownAs: ['元数据驱动的应用开发', '元数据驱动架构', '声明式应用开发'], relatedTerms: [ + 'ontology', 'application-metadata', 'typed-metadata', 'application-definition-vs-runtime', diff --git a/content/glossary/zh-Hans/ontology-projection.ts b/content/glossary/zh-Hans/ontology-projection.ts new file mode 100644 index 0000000..eb29b70 --- /dev/null +++ b/content/glossary/zh-Hans/ontology-projection.ts @@ -0,0 +1,29 @@ +import type { GlossaryTerm } from '../../../src/glossary/types'; + +const term = { + slug: 'ontology-projection', + term: '本体投影', + title: '本体投影：从本体派生出来的视图、仪表盘、应用和翻译', + description: + '本体投影是从可执行业务本体派生出来的视图、仪表盘、应用或翻译：同样以元数据编写、经同一道门禁校验，但不是本体的一部分——改动核心，投影跟着变。', + definition: + '本体投影（Ontology projection）是从一份可执行的业务本体派生出来的视图、仪表盘、应用或翻译——它同样以元数据编写、经同一道门禁校验，但不是本体本身的一部分，所以改动核心时投影跟着变，而删掉一个投影，它所展示的业务原封不动。', + explanation: [ + '本体是运行时直接运行的那份业务定义：对象与字段、关系、动作、权限、流程，以及 Agent 与工具定义。人眼看到的一切都是它的投影。列表视图把一个对象的字段和权限投到一张网格上；仪表盘把对对象的查询投到图表上；应用把对象、视图和动作编成一个可导航的产品；翻译把每个标签投到一种语言里。投影是真实的元数据——同样被编写、有类型、经校验、要审阅——但它描述的是业务怎么被呈现，而不是业务是什么。', + '分辨核心与投影的测试，是删掉它会发生什么。删掉一个看板视图，工单、它们的负责人、谁能编辑它们都原封不动；删掉限定这个看板范围的那条权限，业务就变了。这正是这个区分能圈定 Agent 要装下多少东西才能推理业务的原因：装核心，而不是装每一个界面。它也决定了审阅者读什么：只碰投影的 diff 改的是呈现，碰到核心的 diff 改的是权限。', + '有两样东西不是投影，却常被当成投影。动作是本体的一部分：它定义对一条记录能做什么、在什么条件下能做，Agent 把它当作工具来调用。权限是本体的一部分：视图由权限塑形，而不是定义权限。代码也不是投影——钩子、动作体、CEL 表达式和受限 JSX 在运行时内部运行，和一切从本体派生出来的东西待在同一道权限与审计围栏里。', + ], + alsoKnownAs: ['投影', '视图投影', '本体的投影'], + relatedTerms: [ + 'ontology', + 'application-metadata', + 'typed-metadata', + 'definition-layer', + 'reviewable-diff', + 'object-type-and-action-type', + ], + articleSlugs: ['what-does-the-ontology-is-the-software-mean'], + pageSlugs: ['app-ui'], +} satisfies GlossaryTerm; + +export default term; diff --git a/content/glossary/zh-Hans/ontology.ts b/content/glossary/zh-Hans/ontology.ts index 397d9e4..66f3bff 100644 --- a/content/glossary/zh-Hans/ontology.ts +++ b/content/glossary/zh-Hans/ontology.ts @@ -3,19 +3,20 @@ import type { GlossaryTerm } from '../../../src/glossary/types'; const term = { slug: 'ontology', term: '本体（Ontology）', - title: '企业软件里的本体（Ontology）：定义，以及它归谁所有', + title: '企业软件里的本体（Ontology）：可执行的业务本体，以及它归谁所有', description: - '本体是对一个业务领域的形式化建模——它有哪些类、每个类带哪些属性、彼此之间是什么关系——写成机器可读的形式，让软件和 AI Agent 能对业务本身做推理，而不是对着一堆原始数据表猜。', + '可执行的业务本体，是由运行时直接运行的那份业务定义——对象与字段、关系、动作、权限、流程，以及 Agent 与工具定义——它被校验，而不是被推理。', definition: - '本体（Ontology）在企业语境下，是对一个业务领域的形式化建模——业务打交道的那些类、描述它们的属性、以及把它们连起来的关系——以机器可读的形式表达出来，让软件（如今还有 AI Agent）能够对业务本身做推理，而不是对着一堆原始数据表猜。', + '本体（Ontology）在 ObjectStack 所用的意义上，是一份可执行的业务本体：对一个业务的定义——它的对象与字段、关系、动作、权限、流程，以及 Agent 与工具定义——以类型化元数据写出，由运行时校验后直接运行，让软件和 AI Agent 通过这一份定义去操作业务，而不是对着一堆原始数据表猜。', explanation: [ - '这个词来自哲学，经由知识工程进入企业软件，但真正干活的那层含义很窄也很实用：本体为整个组织一次性命名类型（客户、工单、设备）、每个类型带的属性，以及类型之间的连接。这正是它和数据库 schema 的分界。schema 描述的是某一个应用怎么存自己的行；本体描述的是这家公司所说的「客户」到底指什么，并且要写得让十几个系统、一个报表工具和一个模型都能解析出同一个答案。2026 年多数人想到这个词时脑子里是 Palantir Foundry——它的本体建模质量确实高；微软 Fabric IQ 和 Google 的企业知识图谱也在往同一层挤。', + '本体即软件。在 ObjectStack 里，本体不是某个托管平台内部的一层：它就是应用自己的定义——对象与字段、关系、动作、权限、流程，以及 Agent 与工具定义——由运行时直接运行：数据库、REST API、界面和 MCP 工具都从它派生，权限与审计在每一次调用上执行。这个词带着四条边界。它是可执行的，不是知识表示意义上的本体：没有继承、没有公理、没有推理机——定义被校验，然后被运行。它不是架在你现有系统之上的语义层：它本身就是系统，联邦外部数据源默认只读，且尚在早期。视图、仪表盘、应用和翻译是本体的投影，不是本体的一部分。代码也没有消失：它以钩子、动作体、CEL 和受限 JSX 的形式搬进了运行时。', + '这个词来自哲学，经由知识工程进入企业软件，在那里它指对一个领域的形式化建模——类、属性、关系——让软件能对其推理。那层含义很窄也很实用：本体为整个组织一次性命名类型（客户、工单、设备）、每个类型带的属性，以及类型之间的连接，这正是它和数据库 schema 的分界。schema 描述的是某一个应用怎么存自己的行；本体描述的是这家公司所说的「客户」到底指什么，并且要写得让十几个系统、一个报表工具和一个模型都能解析出同一个答案。2026 年多数人想到这个词时脑子里是 Palantir Foundry——它的本体建模质量确实高；微软 Fabric IQ 和 Google 的企业知识图谱也在往同一层挤。', '大部分本体工作都在风险刚开始的地方停住了。检索级的本体是一个读模型：它让 Agent 把业务说清楚，却对「Agent 要动手改点什么」只字未提。把它补完整的能力，是被声明出来、且做权限校验的写操作——动作（Action）——连同挂在同一份定义上的权限与审计规则。Palantir 多年来一直把写操作收拢进受治理的 Action，这份功劳应该给它；「这个设计对不对」从来不是待议的问题。', - '待议的问题是：这份文件在谁手里。在 ObjectStack 里，本体不是某个托管平台内部的一层：它就是应用自己的定义——对象与字段、关系、动作、权限、流程，以及 Agent 与工具定义——由运行时直接运行。这份定义就是你的业务本体：开放、带版本、归你所有，放在你自己的仓库里，既不是散落在框架各处的代码，也不是锁在厂商系统里的一张图。视图、仪表盘、应用和翻译是本体的投影，不是本体的一部分；代码并没有消失，而是以钩子、动作体、CEL 和受限 JSX 的形式搬进了运行时。一份你能读、能 diff、能搬到另一个宿主上去的定义，和一份同样优秀但住在厂商引擎里、迁移等于重建的定义，是两种不同的资产。这一切归结为 ObjectStack README 开篇的那句话：本体即软件。', - '边界和主张同样重要。ObjectStack 的本体是可执行的，不是知识表示意义上的本体：没有继承、没有公理、没有推理机——它被校验，然后被运行。它也不是架在你现有系统之上的语义层；联邦外部数据源默认只读，且尚在早期。并且，本体不会让 AI Agent 变正确：把业务建模好依然是缓慢的、充满分歧的人的工作，没有哪种格式能替你走完。格式能决定的事情要窄得多——结果是否小到 Agent 能一次读完、是否严格到能在编写时点就把 Agent 的错误挡回去、是否可移植到能活过它最初被写下的那个平台。', + '待议的问题是：这份文件在谁手里。在 ObjectStack 里，这份定义就是你的业务本体：开放、带版本、归你所有，放在你自己的仓库里，既不是散落在框架各处的代码，也不是锁在厂商系统里的一张图。一份你能读、能 diff、能搬到另一个宿主上去的定义，和一份同样优秀但住在厂商引擎里、迁移等于重建的定义，是两种不同的资产。并且，本体不会让 AI Agent 变正确：把业务建模好依然是缓慢的、充满分歧的人的工作，没有哪种格式能替你走完。格式能决定的事情要窄得多——结果是否小到 Agent 能一次读完、是否严格到能在编写时点就把 Agent 的错误挡回去、是否可移植到能活过它最初被写下的那个平台。', ], - alsoKnownAs: ['企业本体', '业务本体', '领域本体'], + alsoKnownAs: ['可执行业务本体', '业务本体', '企业本体', '领域本体'], relatedTerms: [ + 'ontology-projection', 'semantic-layer', 'knowledge-graph', 'object-type-and-action-type', @@ -25,13 +26,14 @@ const term = { 'governed-runtime', ], articleSlugs: [ + 'what-does-the-ontology-is-the-software-mean', 'ai-ontology-open-protocol', 'enterprise-ontology-race-open-vs-closed', 'ontology-vs-semantic-layer-vs-knowledge-graph', 'enterprise-ontology-platform-comparison', 'objectos-action-tools', ], - pageSlugs: ['data-modeling', 'platform', 'ai'], + pageSlugs: ['data-modeling', 'app-ui', 'permissions', 'mcp', 'agent-developer', 'platform', 'ai'], } satisfies GlossaryTerm; export default term; diff --git a/content/pages/en/agent-developer.ts b/content/pages/en/agent-developer.ts index dfcd202..1f4ac3f 100644 --- a/content/pages/en/agent-developer.ts +++ b/content/pages/en/agent-developer.ts @@ -12,7 +12,7 @@ const page = { eyebrow: 'Agent developer', heroTitle: 'Do not teach every developer to hand-write apps. Teach your agent the target format.', lead: - `${p.t2} The agent is the writer and you are the reviewer: the scaffolder writes an AGENTS.md so the agent starts with the protocol’s rules loaded, Strict TypeScript, Zod schemas, and os validate reject invalid output before it reaches the runtime, and the whole app stays small enough for AI to hold whole.`, + `${p.t2} The ontology is what the agent writes — ${p.t3[1]}, in the README’s four promises — and you are the reviewer: the scaffolder writes an AGENTS.md so the agent starts with the protocol’s rules loaded, Strict TypeScript, Zod schemas, and os validate reject invalid output before it reaches the runtime, and the whole app stays small enough for AI to hold whole.`, primary: { label: 'Follow the README path', href: 'https://github.com/objectstack-ai/objectstack#try-it-in-five-minutes' }, secondary: { label: 'See template patterns', href: '/en/templates/' }, metrics: [ @@ -51,8 +51,8 @@ npx os dev --ui # -> http://localhost:3000/_console/`, meta: 'Context', }, { - title: '2. Generate metadata', - body: 'The agent edits object, view, workflow, action, dashboard, translation, and tool definitions as Strict TypeScript rather than generating app glue code.', + title: '2. Write the ontology', + body: 'The agent edits the ontology — objects and fields, relations, actions, permissions, flows, and tool definitions — and its projections — views, dashboards, translations — as Strict TypeScript rather than generating app glue code.', meta: 'Write', }, { diff --git a/content/pages/en/app-ui.ts b/content/pages/en/app-ui.ts index 15670e4..60c55d4 100644 --- a/content/pages/en/app-ui.ts +++ b/content/pages/en/app-ui.ts @@ -9,7 +9,7 @@ const page = { eyebrow: 'App interfaces', heroTitle: 'Screens nobody hand-builds. Views everyone trusts.', lead: - 'Take a support workbench: reps work a grid of open cases, the team lead drags a kanban grouped by status, and everyone checks the due-date calendar. On the open-source ObjectStack runtime that is one view definition — rendered per user, live as records change, and adjustable in the view designer without touching a file. On ObjectOS, the in-app AI Builder registers the same views from a plain-language request.', + 'Take a support workbench: reps work a grid of open cases, the team lead drags a kanban grouped by status, and everyone checks the due-date calendar. On the open-source ObjectStack runtime that is one view definition — a projection of the ontology, not part of it — rendered per user, live as records change, and adjustable in the view designer without touching a file. On ObjectOS, the in-app AI Builder registers the same views from a plain-language request.', primary: { label: 'Read the interface docs', href: 'https://docs.objectos.ai/docs/build/interface' }, secondary: { label: 'See analytics & reporting', href: '/en/analytics/' }, metrics: [ @@ -19,7 +19,7 @@ const page = { ], artifact: { eyebrow: 'A screen as metadata', - title: 'The view is part of the reviewable definition.', + title: 'The view is a projection of the ontology — and still a reviewable diff.', body: 'This is that workbench: a grid with columns, a kanban grouped by status, a calendar on due dates, and a saved “Open Cases” list — one definition. When an agent adds a field, the affected screens are part of the same small diff, not a frontend ticket.', code: `import { defineView } from '@objectstack/spec'; @@ -58,10 +58,10 @@ export const CaseViews = defineView({ sections: [ { id: 'surfaces', - eyebrow: 'Rendered from metadata', + eyebrow: 'Projections of the ontology', title: 'The workbench, surface by surface', copy: - 'Typed fields carry their own widgets and formatting, so generated screens look and behave consistently without a design-system project.', + 'Views, dashboards, apps, and translations are projections of the ontology, not part of it: change the objects and the screens follow; remove a screen and the business it showed is unchanged. Typed fields carry their own widgets and formatting, so the projections look and behave consistently without a design-system project.', items: [ { title: 'Views & lists', diff --git a/content/pages/en/data-modeling.ts b/content/pages/en/data-modeling.ts index 77c4923..c1d420d 100644 --- a/content/pages/en/data-modeling.ts +++ b/content/pages/en/data-modeling.ts @@ -9,7 +9,7 @@ const page = { eyebrow: 'Data modeling', heroTitle: 'Describe the business objects. The database and APIs follow.', lead: - 'Take a subscription-billing system: customers, plans, seats, MRR, renewal dates, status. On the open-source ObjectStack runtime that is one compact object definition — tables, migrations, the query engine, and REST endpoints are supplied by the runtime. Your agent can write it, your team can fine-tune it field by field in the object designer, and on ObjectOS the in-app AI Builder drafts the same objects and fields from a plain-language request.', + 'Take a subscription-billing system: customers, plans, seats, MRR, renewal dates, status. Those objects, their fields, and the relations between them are the core of your business ontology, and on the open-source ObjectStack runtime that core is one compact definition — tables, migrations, the query engine, and REST endpoints are supplied by the runtime. Your agent can write it, your team can fine-tune it field by field in the object designer, and on ObjectOS the in-app AI Builder drafts the same objects and fields from a plain-language request.', primary: { label: 'Read the data modeling docs', href: 'https://docs.objectos.ai/docs/build/data' }, secondary: { label: 'See process automation', href: '/en/automation/' }, metrics: [ @@ -18,7 +18,7 @@ const page = { { value: 'Read-only first', label: 'A database you already run federates in place — read-only by default, writes opt-in, and early' }, ], artifact: { - eyebrow: 'The model is the source', + eyebrow: 'The ontology is the source', title: 'One object definition. Schema, rules, and API included.', body: 'This is that subscription object: fields, relationships, validation, and history tracking in one reviewable definition. The runtime turns it into tables and migrations, enforces the rules on every write, and serves the API — the same definition an agent can extend and the designer can open.', @@ -59,7 +59,7 @@ export const Subscription = ObjectSchema.create({ eyebrow: 'Model the business', title: 'Build the subscription system step by step', copy: - 'Definitions stay close to how the business talks: customers, plans, renewals. No ORM classes, no scattered schema files — every step below stays inside one definition.', + 'The ontology stays close to how the business talks: customers, plans, renewals. No ORM classes, no scattered schema files — every step below stays inside one definition.', items: [ { title: 'Objects & relationships', diff --git a/content/pages/en/mcp.ts b/content/pages/en/mcp.ts index c20a1bb..1c1a84d 100644 --- a/content/pages/en/mcp.ts +++ b/content/pages/en/mcp.ts @@ -12,7 +12,7 @@ const page = { eyebrow: 'Tools & MCP', heroTitle: 'Your business objects, as governed tools for any AI.', lead: - `Most companies wire AI to their data with handwritten glue that bypasses every control they have. The ObjectStack runtime generates governed tools from metadata instead: whatever your model — Claude, Cursor, or something fully local — it works through the same permissions, approvals, and audit as your people. The MCP server ships in the open framework and is on by default in every edition; ObjectOS is ${p.descriptor}, and runs the same server.`, + `Most companies wire AI to their data with handwritten glue that bypasses every control they have. ObjectStack generates governed tools from the ontology instead — ${p.t3[2]} is one of its four promises: the objects your definition declares and the actions it exposes become MCP tools, called under the signed-in user’s own permissions, approvals, and audit, whatever your model — Claude, Cursor, or something fully local. The MCP server ships in the open framework and is on by default in every edition; ObjectOS is ${p.descriptor}, and runs the same server.`, primary: { label: 'Read the MCP docs', href: 'https://docs.objectos.ai/docs/configure/mcp' }, secondary: { label: 'Point your agent at ObjectStack', href: '/en/agent-developer/' }, metrics: [ @@ -46,7 +46,7 @@ claude mcp add --transport http my-app \\ eyebrow: 'What the AI gets', title: 'Tools that already know your business', copy: - 'Because tools derive from the same metadata that defines the application, the AI sees real objects, real relationships, and real actions — not a raw database dump.', + 'Because the tools derive from the ontology that defines the application, the AI sees real objects, real relationships, and real actions — not a raw database dump.', items: [ { title: 'Query business objects', diff --git a/content/pages/en/permissions.ts b/content/pages/en/permissions.ts index 19bf0a4..7b5e451 100644 --- a/content/pages/en/permissions.ts +++ b/content/pages/en/permissions.ts @@ -9,7 +9,7 @@ const page = { eyebrow: 'Permissions & security', heroTitle: 'Who sees what, who changes what — enforced at runtime.', lead: - 'Take a sales organization: reps see only their team’s accounts, the cost field is masked for them, managers see the whole region, and audit wants to know who changed that discount. On the ObjectStack runtime that boundary is one reviewable definition — enforced on every query, API call, and AI tool call, whether the agent is your own over MCP or ObjectOS’s in-app AI.', + 'Take a sales organization: reps see only their team’s accounts, the cost field is masked for them, managers see the whole region, and audit wants to know who changed that discount. On the ObjectStack runtime that boundary is part of the ontology itself — permissions are declared beside the objects they protect, not in a second policy system — and it is the one fence people and agents share: enforced on every query, API call, and AI tool call, whether the agent is your own over MCP or ObjectOS’s in-app AI.', primary: { label: 'Read the permissions docs', href: 'https://docs.objectos.ai/docs/configure/permissions' }, secondary: { label: 'Review the trust model', href: '/en/trust-center/' }, metrics: [ @@ -108,7 +108,7 @@ const page = { eyebrow: 'AI under the same rules', title: 'Agents get your permission model, not a service account', copy: - 'The fastest way to lose control of AI is to give it superuser access. The ObjectStack runtime never does: every agent action runs as the signed-in user who asked for it.', + 'The fastest way to lose control of AI is to give it superuser access. The ObjectStack runtime never does: every agent action runs as the signed-in user who asked for it, inside the same fence as that user.', items: [ { title: 'User-scoped execution', diff --git a/content/pages/zh-Hans/agent-developer.ts b/content/pages/zh-Hans/agent-developer.ts index 47e579d..e5fcb11 100644 --- a/content/pages/zh-Hans/agent-developer.ts +++ b/content/pages/zh-Hans/agent-developer.ts @@ -12,7 +12,7 @@ const page = { eyebrow: 'Agent 开发指南', heroTitle: '别教每个开发者手写应用。教你的 Agent 目标格式。', lead: - `${p.t2}Agent 是作者，你是审阅者：脚手架写入 AGENTS.md，让 Agent 一开始就带着协议规则；Strict TypeScript、Zod schema 与 os validate 会在无效输出进入运行时前将其拒掉；整个应用小到 AI 能整体装下。`, + `${p.t2}Agent 写的就是本体——四个承诺里的「${p.t3[1]}」——你是审阅者：脚手架写入 AGENTS.md，让 Agent 一开始就带着协议规则；Strict TypeScript、Zod schema 与 os validate 会在无效输出进入运行时前将其拒掉；整个应用小到 AI 能整体装下。`, primary: { label: '照 README 路径走', href: 'https://github.com/objectstack-ai/objectstack#try-it-in-five-minutes' }, secondary: { label: '查看模板模式', href: '/en/templates/' }, metrics: [ @@ -51,8 +51,8 @@ npx os dev --ui # -> http://localhost:3000/_console/`, meta: '上下文', }, { - title: '2. 生成元数据', - body: 'Agent 以 Strict TypeScript 编辑对象、视图、流程、动作、仪表盘、翻译与工具定义，而不是生成应用胶水代码。', + title: '2. 编写本体', + body: 'Agent 以 Strict TypeScript 编辑本体——对象与字段、关系、动作、权限、流程与工具定义——及其投影——视图、仪表盘、翻译——而不是生成应用胶水代码。', meta: '编写', }, { diff --git a/content/pages/zh-Hans/app-ui.ts b/content/pages/zh-Hans/app-ui.ts index 7ee01ef..be2d6a5 100644 --- a/content/pages/zh-Hans/app-ui.ts +++ b/content/pages/zh-Hans/app-ui.ts @@ -9,7 +9,7 @@ const page = { eyebrow: '应用界面', heroTitle: '没人手写的界面，人人信得过的视图。', lead: - '拿一个客服工作台来说：客服在网格里处理待办工单，主管拖着按状态分组的看板，所有人都会看截止日历。在开源 ObjectStack 运行时上这是一份视图定义——按用户渲染、随记录实时变化，还能在视图设计器里调整，不碰一个文件。在 ObjectOS 上，产品内 AI Builder 能从一句描述注册出同样的视图。', + '拿一个客服工作台来说：客服在网格里处理待办工单，主管拖着按状态分组的看板，所有人都会看截止日历。在开源 ObjectStack 运行时上这是一份视图定义——本体的投影，而不是本体的一部分——按用户渲染、随记录实时变化，还能在视图设计器里调整，不碰一个文件。在 ObjectOS 上，产品内 AI Builder 能从一句描述注册出同样的视图。', primary: { label: '阅读界面文档', href: 'https://docs.objectos.ai/docs/build/interface' }, secondary: { label: '查看报表与分析', href: '/en/analytics/' }, metrics: [ @@ -19,7 +19,7 @@ const page = { ], artifact: { eyebrow: '界面即元数据', - title: '视图是可审阅定义的一部分。', + title: '视图是本体的投影——同时仍是一份可审阅的 diff。', body: '这就是那个工作台：带列的网格、按状态分组的看板、截止日历，还有一个存好的"待办工单"列表——一份定义。Agent 加一个字段时，受影响的界面就在同一份小 diff 里，而不是另开一张前端工单。', code: `import { defineView } from '@objectstack/spec'; @@ -58,10 +58,10 @@ export const CaseViews = defineView({ sections: [ { id: 'surfaces', - eyebrow: '从元数据渲染', + eyebrow: '本体的投影', title: '把工作台一个面一个面看过去', copy: - '类型化字段自带控件与格式，生成的界面外观行为天然一致——不需要先做一个设计系统项目。', + '视图、仪表盘、应用和翻译是本体的投影，不是本体的一部分：改对象，界面跟着变；删掉一个界面，它所展示的业务原封不动。类型化字段自带控件与格式，投影出来的界面外观行为天然一致——不需要先做一个设计系统项目。', items: [ { title: '视图与列表', diff --git a/content/pages/zh-Hans/data-modeling.ts b/content/pages/zh-Hans/data-modeling.ts index 26efd97..d7f695e 100644 --- a/content/pages/zh-Hans/data-modeling.ts +++ b/content/pages/zh-Hans/data-modeling.ts @@ -9,7 +9,7 @@ const page = { eyebrow: '数据建模', heroTitle: '描述业务对象，数据库和 API 随之而来。', lead: - '以一个订阅计费系统为例：客户、套餐、席位、MRR、续约日、状态。在开源 ObjectStack 运行时上，这就是一份紧凑的对象定义——表、迁移、查询引擎和 REST 端点由运行时供给；你的 Agent 能写它，你的团队能在对象设计器里逐字段微调它，而在 ObjectOS 上，产品内 AI Builder 能从一句描述起草出同样的对象与字段。', + '以一个订阅计费系统为例：客户、套餐、席位、MRR、续约日、状态。这些对象、它们的字段，以及它们之间的关系，就是你的业务本体的核心；在开源 ObjectStack 运行时上，这个核心就是一份紧凑的定义——表、迁移、查询引擎和 REST 端点由运行时供给；你的 Agent 能写它，你的团队能在对象设计器里逐字段微调它，而在 ObjectOS 上，产品内 AI Builder 能从一句描述起草出同样的对象与字段。', primary: { label: '阅读数据建模文档', href: 'https://docs.objectos.ai/docs/build/data' }, secondary: { label: '查看流程自动化', href: '/en/automation/' }, metrics: [ @@ -18,7 +18,7 @@ const page = { { value: '先只读', label: '已在运行的数据库原地联邦接入——默认只读、写权限按需开启、尚在早期' }, ], artifact: { - eyebrow: '模型即源码', + eyebrow: '本体即源码', title: '一份对象定义，schema、规则和 API 全在里面。', body: '这就是那个订阅对象：字段、关系、校验和历史追踪都在一份可审阅的定义里。运行时把它变成表和迁移，在每条写路径上执行规则，并对外提供 API——同一份定义，Agent 能读懂扩展，设计器能打开微调。', @@ -59,7 +59,7 @@ export const Subscription = ObjectSchema.create({ eyebrow: '为业务建模', title: '把订阅系统一步步建出来', copy: - '定义贴着业务的说法走：客户、套餐、续约。没有 ORM 类，没有散落各处的 schema 文件——下面每一步都停留在同一份定义里。', + '本体贴着业务的说法走：客户、套餐、续约。没有 ORM 类，没有散落各处的 schema 文件——下面每一步都停留在同一份定义里。', items: [ { title: '对象与关系', diff --git a/content/pages/zh-Hans/mcp.ts b/content/pages/zh-Hans/mcp.ts index b361b73..6bc84ae 100644 --- a/content/pages/zh-Hans/mcp.ts +++ b/content/pages/zh-Hans/mcp.ts @@ -12,7 +12,7 @@ const page = { eyebrow: '工具与 MCP', heroTitle: '你的业务对象，成为任意 AI 的受治理工具。', lead: - `多数公司用手写的胶水代码把 AI 接到数据上，绕过了自己建立的所有控制。ObjectStack 运行时则直接从元数据生成受治理工具：无论你的模型是 Claude、Cursor 还是完全本地的模型，它都走和员工一样的权限、审批与审计。MCP 服务器随开源框架发布，在每个版本中默认开启；ObjectOS 是${p.descriptor}，跑的是同一个服务器。`, + `多数公司用手写的胶水代码把 AI 接到数据上，绕过了自己建立的所有控制。ObjectStack 则直接从本体生成受治理工具——${p.t3[2]}是它的四个承诺之一：你的定义声明的对象、它暴露的动作成为 MCP 工具，以登录用户自己的权限、审批与审计被调用，无论你的模型是 Claude、Cursor 还是完全本地的模型。MCP 服务器随开源框架发布，在每个版本中默认开启；ObjectOS 是${p.descriptor}，跑的是同一个服务器。`, primary: { label: '阅读 MCP 文档', href: 'https://docs.objectos.ai/docs/configure/mcp' }, secondary: { label: '把你的 Agent 指向 ObjectStack', href: '/en/agent-developer/' }, metrics: [ @@ -46,7 +46,7 @@ claude mcp add --transport http my-app \\ eyebrow: 'AI 拿到什么', title: '天生就懂你业务的工具', copy: - '因为工具派生自定义应用的同一份元数据，AI 看到的是真实的对象、真实的关系、真实的动作——而不是一堆裸数据库表。', + '因为工具派生自定义这个应用的那份本体，AI 看到的是真实的对象、真实的关系、真实的动作——而不是一堆裸数据库表。', items: [ { title: '查询业务对象', diff --git a/content/pages/zh-Hans/permissions.ts b/content/pages/zh-Hans/permissions.ts index c14c549..11ea9b7 100644 --- a/content/pages/zh-Hans/permissions.ts +++ b/content/pages/zh-Hans/permissions.ts @@ -9,7 +9,7 @@ const page = { eyebrow: '权限与安全', heroTitle: '谁能看什么、谁能改什么——在运行时强制执行。', lead: - '拿一个销售组织来说：代表只能看自己团队的客户，成本价字段对他们脱敏，经理能看整个大区，审计随时要查"这条折扣谁改的"。在 ObjectStack 运行时上，这套边界是一份可审阅的定义——在每一次查询、API 调用和 AI 工具调用上强制执行，无论 Agent 是你自己经 MCP 接入的，还是 ObjectOS 的产品内 AI。', + '拿一个销售组织来说：代表只能看自己团队的客户，成本价字段对他们脱敏，经理能看整个大区，审计随时要查"这条折扣谁改的"。在 ObjectStack 运行时上，这套边界就是本体的一部分——权限声明在它所保护的对象旁边，而不是另一套策略系统——也是人和 Agent 共用的同一道围栏：在每一次查询、API 调用和 AI 工具调用上强制执行，无论 Agent 是你自己经 MCP 接入的，还是 ObjectOS 的产品内 AI。', primary: { label: '阅读权限文档', href: 'https://docs.objectos.ai/docs/configure/permissions' }, secondary: { label: '查看信任模型', href: '/en/trust-center/' }, metrics: [ @@ -108,7 +108,7 @@ const page = { eyebrow: 'AI 同规', title: 'Agent 拿到的是你的权限模型，不是服务账号', copy: - '失去 AI 控制最快的方式就是给它超级用户权限。ObjectStack 运行时从不这么做：每个 Agent 动作都以发起它的登录用户身份执行。', + '失去 AI 控制最快的方式就是给它超级用户权限。ObjectStack 运行时从不这么做：每个 Agent 动作都以发起它的登录用户身份执行，待在和这个用户同一道围栏里。', items: [ { title: '用户级执行', diff --git a/src/lib/cluster-i18n.ts b/src/lib/cluster-i18n.ts index f1b1325..3607eed 100644 --- a/src/lib/cluster-i18n.ts +++ b/src/lib/cluster-i18n.ts @@ -43,13 +43,17 @@ type TextTemplates = { }; const NAMES: Record = { + // The slug and URL keep the category name people search for; the copy no + // longer defines the product by it. The name is a noun phrase because the + // per-locale templates below interpolate it mid-sentence (ko keeps a final + // consonant so the templates' 이/은 particles stay right). 'ai-native-app-platform': { - 'zh-Hans': { title: 'AI-native 应用平台', shortTitle: 'AI-native 应用平台' }, - ja: { title: 'AI-native アプリプラットフォーム', shortTitle: 'AI-native アプリ' }, - de: { title: 'AI-native App-Plattform', shortTitle: 'AI-native App-Plattform' }, - es: { title: 'Plataforma de aplicaciones AI-native', shortTitle: 'Plataforma AI-native' }, - fr: { title: 'Plateforme applicative AI-native', shortTitle: 'Plateforme AI-native' }, - ko: { title: 'AI-native 앱 플랫폼', shortTitle: 'AI-native 앱 플랫폼' }, + 'zh-Hans': { title: '可执行的业务本体', shortTitle: '可执行业务本体' }, + ja: { title: '実行可能なビジネスオントロジー', shortTitle: '実行可能なオントロジー' }, + de: { title: 'Ausführbare Geschäftsontologie', shortTitle: 'Ausführbare Geschäftsontologie' }, + es: { title: 'Ontología de negocio ejecutable', shortTitle: 'Ontología ejecutable' }, + fr: { title: 'Ontologie métier exécutable', shortTitle: 'Ontologie exécutable' }, + ko: { title: '실행 가능한 비즈니스 온톨로지 플랫폼', shortTitle: '실행 가능한 온톨로지' }, }, 'legacy-system-modernization': { 'zh-Hans': { title: '用 AI 做遗留系统现代化', shortTitle: '遗留系统现代化' }, @@ -101,11 +105,11 @@ const TEMPLATES: Record = { whyNow: '为什么现在重要', }, description: (name) => - `了解 ${name} 如何连接现有业务系统、建模业务对象，并让 AI 在权限、审批和审计边界内工作。`, + `了解 ${name} 如何连接现有业务系统、把业务建模成一份可执行的本体，并让 AI 在权限、审批和审计边界内工作。`, lead: (name) => - `${name} 的核心不是再做一个演示页面，而是把真实业务对象、权限、流程、API 和 Agent 工具组织成一个可治理的运行层。`, + `${name} 的核心不是再做一个演示页面，而是一份可执行的业务本体：对象与字段、关系、动作、权限、流程，以及 Agent 与工具定义。视图、仪表盘、应用和翻译是它的投影，不是产品本身。`, definition: (name) => - `${name} 把客户、工单、订单、设备、合同和审批等业务记录变成 AI 可以理解和调用的结构化对象。ObjectOS 让 AI 使用明确的工具和权限边界，而不是直接绕过系统访问数据。`, + `${name} 把客户、工单、订单、设备、合同和审批等业务记录写进同一份本体：对象、权限、动作和流程声明在一起，运行时从中派生数据库、API、界面和 MCP 工具，并在每一次调用上执行权限与审计。ObjectOS 让 AI 使用明确的工具和权限边界，而不是直接绕过系统访问数据。`, whyNow: (name) => [ `${name} 让企业 AI 面向真实业务记录，而不是一次性的导出文件。`, '应用生成之后还需要权限、审计、审批和持续演进能力。', @@ -131,7 +135,7 @@ const TEMPLATES: Record = { { question: '这和低代码有什么不同？', answer: - '低代码主要加速表单和流程搭建。ObjectOS 更关注底层业务对象、权限治理、系统集成、Agent 工具和长期演进。', + '低代码平台是最近的亲戚：那里同样由元数据生成表、API 和界面。区别在定义放在哪里、写给谁看。低代码把元数据当作配置存在厂商的数据库里、由人在界面上点出来；ObjectStack 把它写成你仓库里类型化、声明式的 TypeScript——进版本库、按 diff 审阅、运行前经 os validate 校验，并且是为 AI 来写而设计的。', }, { question: '是否需要先替换现有系统？', diff --git a/src/lib/clusters.ts b/src/lib/clusters.ts index 78366d1..d7e6b51 100644 --- a/src/lib/clusters.ts +++ b/src/lib/clusters.ts @@ -23,50 +23,54 @@ export interface Cluster { export const CLUSTERS: Cluster[] = [ { + // The slug and URL keep the category name people search for — the home + // page and llms.txt link this page in every locale — but the copy defines + // the product by the ontology, not by the category. slug: 'ai-native-app-platform', - title: 'AI-Native App Platform', - shortTitle: 'AI-native app platform', + title: 'What Is an AI-Native App Platform? One Executable Business Ontology', + shortTitle: 'Executable business ontology', description: - '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.', + 'An AI-native app platform, defined the way ObjectStack defines it: one executable business ontology that AI writes, an open runtime runs, agents operate, and you own — how that differs from low-code and from AI code generation, and where ObjectOS fits.', eyebrow: 'Pillar guide', lead: - 'An AI-native app platform is built around business objects, permissions, workflows, APIs, and agent tools from the start. It is not a page builder with a chat box; it is a governed runtime for AI-written business software.', + 'People search for an AI-native app platform and mean a place where AI-written business software can land and stay governable. ObjectStack’s answer is not a page builder with a chat box. It is one executable business ontology — objects and fields, relations, actions, permissions, flows, and agent and tool definitions — and the open runtime that runs it; the screens are projections of that definition, not the product.', definition: - 'An AI-native app platform turns requirements into structured application metadata: objects, fields, relationships, views, permissions, workflows, actions, APIs, and tools that agents can call. The platform gives AI a model of the business system instead of asking it to generate disconnected code.', + 'An executable business ontology is the definition of a business that a runtime runs. AI writes it as typed metadata in your repository; the ObjectStack runtime derives the database, REST API, screens, and MCP tools from it and enforces permissions and audit on every call; agents operate it under the same permissions as people; and you own the files, Apache-2.0. ObjectOS runs the same loop hosted or self-managed, with in-app AI, approvals, and operations on top.', whyNow: [ - 'Enterprise AI needs access to real business records, not exported snapshots.', - 'Generated apps need permissions, audit trails, and lifecycle control after the first version ships.', - 'Business teams need systems that keep evolving as rules, integrations, and operating models change.', + 'Anyone can make an AI generate an app now; the bottleneck moved to reviewing, governing, and trusting what the AI wrote.', + 'Generated apps need permissions, audit trails, and lifecycle control after the first version ships — rules a runtime enforces, not rules a prompt remembers.', + 'A business keeps changing its rules, integrations, and operating model; a definition an agent can hold whole stays changeable, a generated codebase does not.', ], capabilities: [ - 'Object modeling for customers, orders, cases, devices, contracts, approvals, and other business records.', - 'Metadata-driven screens, workflows, APIs, and agent tools generated from the same business specification.', - 'Permission-aware execution so users and AI agents operate inside the same governance boundary.', - 'Federation of a database you already run — read-only by default, and early — so the platform can read what already runs instead of forcing a migration.', + 'Executable: objects and fields, relations, actions, permissions, flows, and agent and tool definitions as typed metadata the runtime validates and runs — validated, not reasoned over.', + 'AI-writable: a coding agent writes the definition; Strict TypeScript, Zod schemas, and os validate reject what would fail at runtime; a person reviews a small diff instead of generated glue.', + 'Agent-operable: every object and exposed action doubles as a governed MCP tool, called under the signed-in user’s permissions, approvals, and audit.', + 'You own it: the definition lives in your repository under Apache-2.0, and a database you already run federates in place — read-only by default, and early.', ], useCases: [ - 'Turn a repair, service, approval, or internal operations requirement into a running application.', - 'Replace fragile low-code prototypes with governed applications that can survive complexity.', + 'Turn a repair, service, approval, or internal operations requirement into a running application your agent writes and your team reviews.', + 'Replace fragile low-code prototypes with an ontology the runtime governs and an agent can refactor whole.', 'Expose business objects to AI agents without handing them direct database or administrator access.', ], faq: [ { question: 'What is an AI-native app platform?', answer: - 'An AI-native app platform is an application runtime designed so AI can help model, generate, operate, and evolve business software. It treats objects, permissions, workflows, APIs, and agent tools as first-class metadata.', + 'In ObjectStack’s terms, an executable business ontology plus the runtime that runs it: the business is defined once — objects and fields, relations, actions, permissions, flows, and agent and tool definitions — AI writes that definition, the runtime derives and enforces everything else, agents operate it, and you own it. Views, dashboards, apps, and translations are projections of the ontology, not part of it.', }, { - question: 'How is an AI-native app platform different from low-code?', + question: 'How is it different from low-code?', answer: - 'Low-code usually accelerates forms, pages, and workflows. An AI-native app platform focuses on the operating layer underneath them: business objects, governance, integrations, generated APIs, agent tools, and long-term change.', + 'Low-code platforms are the closest relatives: metadata generates tables, APIs, and UI there too. The difference is where the definition lives and who it is written for. Low-code keeps metadata as configuration in the vendor’s database, edited through its UI by a person; ObjectStack keeps it as typed, declarative TypeScript in your repository — versioned and reviewed as a diff, checked by os validate before it runs, and shaped for an AI to write.', }, { - question: 'Does AI-native mean the AI writes all the code?', + question: 'Where does the code go?', answer: - 'No. The important shift is that AI works with structured application metadata and a governed runtime. Code may still exist, but the business model, permissions, and tools remain explicit and inspectable.', + 'Code does not disappear; it moves into the runtime. Hooks, action bodies, CEL expressions, and constrained JSX run inside the same permission and audit fence as everything derived from the ontology. What goes away is the generated codebase a definition would otherwise have to describe — and that no agent could hold whole.', }, ], articleSlugs: [ + 'what-does-the-ontology-is-the-software-mean', 'from-requirement-to-app', 'low-code-vs-ai-native-app-platform', 'extend-existing-systems-with-ai', diff --git a/src/lib/home.ts b/src/lib/home.ts index c70c2b1..5abe25a 100644 --- a/src/lib/home.ts +++ b/src/lib/home.ts @@ -8,6 +8,10 @@ import { positioning } from './positioning'; // eyebrow is T4's noun phrase for ObjectOS, sentence-cased (the CSS uppercases // it anyway). const sentenceCase = (s: string): string => s.charAt(0).toUpperCase() + s.slice(1); +// The media note under the hero image is titled with T2's first sentence — +// "One executable business ontology" in each locale — read from positioning +// rather than spelled here, so it cannot drift from the canonical line. +const t2Lead = (t2: string): string => t2.split(/(?<=[.。])\s*/)[0].replace(/[.。]$/, ''); interface HomeCopy { title: string; @@ -112,7 +116,7 @@ const zhHans: HomeCopy = { [positioning['zh-Hans'].t3[3], '导出本体，拿到开源 ObjectStack 上运行'], ], imageAlt: 'ObjectOS 连接业务数据、应用和 AI Agent 的产品示意图', - imageNoteTitle: '统一业务对象层', + imageNoteTitle: t2Lead(positioning['zh-Hans'].t2), imageNote: '正在连接应用、数据与 Agent', positioningKicker: positioning['zh-Hans'].t1, positioningTitle: ['保留已经有效的系统，', '补上 Agent 可治理运行时。'], @@ -123,7 +127,7 @@ const zhHans: HomeCopy = { capabilities: [ { title: '给 Agent 一个业务模型', copy: '把客户、订单、设备、工单和审批建模成对象，让 Agent 能准确读取、关联和操作。' }, { title: '接入已在运行的系统——先只读', copy: '把已经在跑的数据库作为外部数据源联邦接入，再把它的表建模成对象。联邦默认只读、尚在早期：记录系统继续写入数据，写权限按对象有意开启。' }, - { title: '生成元数据，而不是整套代码', copy: '对典型 CRUD 和流程型软件，Agent 编写紧凑的 ObjectStack 定义，开源 ObjectStack 运行时派生表、API、界面和工具，并强制执行权限与审计；ObjectOS 负责团队的生产部署与运营。要生成的代码更少，要审的代码也更少。' }, + { title: '编写本体，而不是整套代码', copy: '对典型 CRUD 和流程型软件，Agent 把业务本体——对象与字段、关系、动作、权限、流程——写成一份紧凑的 ObjectStack 定义，开源 ObjectStack 运行时从中派生表、API、界面和工具，并强制执行权限与审计；ObjectOS 负责团队的生产部署与运营。要生成的代码更少，要审的代码也更少。' }, { title: '在运行时执行治理', copy: '复用企业身份、权限、审批队列和审计日志，让每一次 Agent 操作都有明确边界。' }, ], aiKicker: 'AI 构建与 Agent 运行', @@ -164,7 +168,7 @@ const zhHans: HomeCopy = { ], securityLink: '了解安全与治理', insightsKicker: '最新洞察', - insightsTitle: '关于 AI-native 软件的实践思考', + insightsTitle: '关于 AI 编写的软件的实践思考', insightsLink: '浏览全部文章', closingKicker: '下一步', closingTitle: '从你最熟悉的一套业务数据开始。', @@ -200,7 +204,7 @@ const en: HomeCopy = { [positioning.en.t3[3], 'Export your ontology, run it on open-source ObjectStack'], ], imageAlt: 'ObjectOS connecting business data, applications, and AI agents', - imageNoteTitle: 'Unified business object layer', + imageNoteTitle: t2Lead(positioning.en.t2), imageNote: 'Connecting applications, data, and agents', positioningKicker: positioning.en.t1, positioningTitle: ['Keep the systems that work.', 'Add a governed runtime for agents.'], @@ -211,7 +215,7 @@ const en: HomeCopy = { capabilities: [ { title: 'Give agents a business model', copy: 'Model customers, orders, equipment, cases, and approvals as objects agents can read, relate, and act on.' }, { title: 'Extend what already runs — read-only first', copy: 'Federate a database you already run as an external datasource and model its tables as objects. Federation is read-only by default and early: the system of record keeps writing the rows, and writes are enabled deliberately, per object.' }, - { title: 'Generate metadata, not app code', copy: 'For typical CRUD and workflow software, agents write the compact ObjectStack definition; the open ObjectStack runtime derives tables, APIs, UI, and tools, then enforces permissions and audit, while ObjectOS handles production deployment and team operations. Less code to generate, less code to review.' }, + { title: 'Write the ontology, not app code', copy: 'For typical CRUD and workflow software, agents write the business ontology — objects and fields, relations, actions, permissions, flows — as one compact ObjectStack definition; the open ObjectStack runtime derives tables, APIs, UI, and tools from it, then enforces permissions and audit, while ObjectOS handles production deployment and team operations. Less code to generate, less code to review.' }, { title: 'Enforce governance at runtime', copy: 'Reuse enterprise identity, permissions, approval queues, and audit logs so every agent action has a defined boundary.' }, ], aiKicker: 'AI build and agent operations', @@ -252,7 +256,7 @@ const en: HomeCopy = { ], securityLink: 'Explore security and governance', insightsKicker: 'Latest insights', - insightsTitle: 'Practical thinking on AI-native software', + insightsTitle: 'Practical thinking on AI-written software', insightsLink: 'Browse all articles', closingKicker: 'Next step', closingTitle: 'Start with the business data you know best.', @@ -289,7 +293,7 @@ const ja: HomeCopy = { [positioning.ja.t3[3], 'オントロジーをエクスポートし、オープンソースの ObjectStack で実行'], ], imageAlt: '業務データ、アプリ、AI エージェントを接続する ObjectOS', - imageNoteTitle: '統一業務オブジェクト層', + imageNoteTitle: t2Lead(positioning.ja.t2), imageNote: 'アプリ、データ、エージェントを接続中', positioningKicker: positioning.ja.t1, positioningTitle: ['今あるシステムを活かし、', 'エージェント用の統制ランタイムを加える。'], @@ -300,7 +304,7 @@ const ja: HomeCopy = { capabilities: [ { title: 'エージェントに業務モデルを渡す', copy: '顧客、注文、設備、ケース、承認を、エージェントが読み、関連付け、操作できるオブジェクトとしてモデル化します。' }, { title: '今あるシステムを活かす — まずは読み取り専用で', copy: 'すでに稼働中のデータベースを外部データソースとしてフェデレートし、そのテーブルをオブジェクトとしてモデル化します。フェデレーションは既定で読み取り専用で、まだ初期段階です。記録システムが行を書き続け、書き込みはオブジェクト単位で意図的に有効化します。' }, - { title: 'コードではなくメタデータを生成', copy: '典型的な CRUD/ワークフロー型ソフトウェアでは、エージェントはコンパクトな ObjectStack 定義を書きます。オープンな ObjectStack ランタイムがテーブル、API、UI、ツールを派生し、権限と監査を強制します。ObjectOS が本番デプロイとチーム運用を担います。生成するコードもレビューするコードも少なくなります。' }, + { title: 'コードではなくオントロジーを書く', copy: '典型的な CRUD/ワークフロー型ソフトウェアでは、エージェントはコンパクトな ObjectStack 定義を書きます。オープンな ObjectStack ランタイムがテーブル、API、UI、ツールを派生し、権限と監査を強制します。ObjectOS が本番デプロイとチーム運用を担います。生成するコードもレビューするコードも少なくなります。' }, { title: 'ランタイムでガバナンスを実行', copy: '企業 ID、権限、承認キュー、監査ログを再利用し、すべてのエージェント操作に明確な境界を設けます。' }, ], aiKicker: 'AI 構築とエージェント運用', @@ -341,7 +345,7 @@ const ja: HomeCopy = { ], securityLink: 'セキュリティとガバナンスを見る', insightsKicker: '最新インサイト', - insightsTitle: 'AI-native ソフトウェアの実践知', + insightsTitle: 'AI が書くソフトウェアの実践知', insightsLink: 'すべての記事', closingKicker: '次のステップ', closingTitle: '最もよく知る業務データから始めましょう。', @@ -378,7 +382,7 @@ const de: HomeCopy = { [positioning.de.t3[3], 'Ontologie exportieren, auf quelloffenem ObjectStack ausführen'], ], imageAlt: 'ObjectOS verbindet Geschäftsdaten, Anwendungen und AI Agents', - imageNoteTitle: 'Einheitliche Geschäftsobjektschicht', + imageNoteTitle: t2Lead(positioning.de.t2), imageNote: 'Verbindet Anwendungen, Daten und Agents', positioningKicker: positioning.de.t1, positioningTitle: ['Bewährte Systeme behalten.', 'Eine kontrollierte Runtime für Agents ergänzen.'], @@ -389,7 +393,7 @@ const de: HomeCopy = { capabilities: [ { title: 'Agents ein Geschäftsmodell geben', copy: 'Modellieren Sie Kunden, Aufträge, Anlagen, Fälle und Freigaben als Objekte, die Agents lesen, verknüpfen und bearbeiten können.' }, { title: 'Bestehendes erweitern — zuerst nur lesend', copy: 'Föderieren Sie eine Datenbank, die Sie bereits betreiben, als externe Datasource und modellieren Sie ihre Tabellen als Objekte. Föderation ist standardmäßig nur lesend und noch früh: Das Ursprungssystem schreibt die Zeilen weiter, Schreibzugriff wird bewusst pro Objekt freigegeben.' }, - { title: 'Metadaten statt App-Code generieren', copy: 'Für typische CRUD- und Workflow-Software schreiben Agents die kompakte ObjectStack-Definition. Die offene ObjectStack Runtime leitet Tabellen, APIs, UI und Tools ab und setzt Rechte sowie Audit durch; ObjectOS übernimmt Produktionsbereitstellung und Team-Betrieb. Weniger Code zu generieren, weniger Code zu prüfen.' }, + { title: 'Die Ontologie schreiben, nicht App-Code', copy: 'Für typische CRUD- und Workflow-Software schreiben Agents die kompakte ObjectStack-Definition. Die offene ObjectStack Runtime leitet Tabellen, APIs, UI und Tools ab und setzt Rechte sowie Audit durch; ObjectOS übernimmt Produktionsbereitstellung und Team-Betrieb. Weniger Code zu generieren, weniger Code zu prüfen.' }, { title: 'Governance zur Laufzeit erzwingen', copy: 'Nutzen Sie Unternehmensidentität, Berechtigungen, Freigabeschlangen und Audit-Logs, damit jede Agent-Aktion klare Grenzen hat.' }, ], aiKicker: 'AI-Build und Agent-Betrieb', @@ -430,7 +434,7 @@ const de: HomeCopy = { ], securityLink: 'Sicherheit und Governance ansehen', insightsKicker: 'Aktuelle Einblicke', - insightsTitle: 'Praxiswissen zu AI-nativer Software', + insightsTitle: 'Praxiswissen zu AI-geschriebener Software', insightsLink: 'Alle Artikel', closingKicker: 'Nächster Schritt', closingTitle: 'Beginnen Sie mit den Geschäftsdaten, die Sie am besten kennen.', @@ -467,7 +471,7 @@ const es: HomeCopy = { [positioning.es.t3[3], 'Exporta tu ontología y ejecútala en ObjectStack open source'], ], imageAlt: 'ObjectOS conectando datos, aplicaciones y agentes de AI', - imageNoteTitle: 'Capa unificada de objetos de negocio', + imageNoteTitle: t2Lead(positioning.es.t2), imageNote: 'Conectando aplicaciones, datos y agentes', positioningKicker: positioning.es.t1, positioningTitle: ['Conserva los sistemas que funcionan.', 'Añade un runtime gobernado para agentes.'], @@ -478,7 +482,7 @@ const es: HomeCopy = { capabilities: [ { title: 'Da a los agentes un modelo de negocio', copy: 'Modela clientes, pedidos, equipos, casos y aprobaciones como objetos que los agentes pueden leer, relacionar y modificar.' }, { title: 'Extiende lo que ya funciona — primero en solo lectura', copy: 'Federa una base de datos que ya usas como datasource externa y modela sus tablas como objetos. La federación es de solo lectura por defecto y aún temprana: el sistema de registro sigue escribiendo las filas y las escrituras se habilitan deliberadamente, objeto por objeto.' }, - { title: 'Genera metadatos, no código de app', copy: 'Para software CRUD y de workflow típico, los agentes escriben la definición compacta de ObjectStack. El runtime abierto de ObjectStack deriva tablas, API, UI y herramientas, y aplica permisos y auditoría; ObjectOS se encarga del despliegue en producción y la operación del equipo. Menos código que generar, menos código que revisar.' }, + { title: 'Escribe la ontología, no código de app', copy: 'Para software CRUD y de workflow típico, los agentes escriben la definición compacta de ObjectStack. El runtime abierto de ObjectStack deriva tablas, API, UI y herramientas, y aplica permisos y auditoría; ObjectOS se encarga del despliegue en producción y la operación del equipo. Menos código que generar, menos código que revisar.' }, { title: 'Aplica gobierno en runtime', copy: 'Reutiliza identidad empresarial, permisos, colas de aprobación y auditoría para que cada acción de agente tenga límites definidos.' }, ], aiKicker: 'Construcción AI y operación con agentes', @@ -519,7 +523,7 @@ const es: HomeCopy = { ], securityLink: 'Ver seguridad y gobierno', insightsKicker: 'Últimos análisis', - insightsTitle: 'Ideas prácticas sobre software AI-native', + insightsTitle: 'Ideas prácticas sobre software escrito por AI', insightsLink: 'Ver todos los artículos', closingKicker: 'Siguiente paso', closingTitle: 'Empieza con los datos de negocio que mejor conoces.', @@ -556,7 +560,7 @@ const fr: HomeCopy = { [positioning.fr.t3[3], 'Exportez votre ontologie, exécutez-la sur ObjectStack open source'], ], imageAlt: 'ObjectOS connectant données métier, applications et agents AI', - imageNoteTitle: 'Couche unifiée d’objets métier', + imageNoteTitle: t2Lead(positioning.fr.t2), imageNote: 'Connexion des applications, données et agents', positioningKicker: positioning.fr.t1, positioningTitle: ['Conservez les systèmes efficaces.', 'Ajoutez un runtime gouverné pour agents.'], @@ -567,7 +571,7 @@ const fr: HomeCopy = { capabilities: [ { title: 'Donnez aux agents un modèle métier', copy: 'Modélisez clients, commandes, équipements, dossiers et validations comme des objets que les agents peuvent lire, relier et modifier.' }, { title: 'Étendez l’existant — en lecture seule d’abord', copy: 'Fédérez une base que vous exploitez déjà comme datasource externe et modélisez ses tables en objets. La fédération est en lecture seule par défaut, et encore récente : le système de référence continue d’écrire les lignes, et l’écriture s’active délibérément, objet par objet.' }, - { title: 'Générez des métadonnées, pas du code applicatif', copy: 'Pour les logiciels CRUD et workflow typiques, les agents écrivent la définition ObjectStack compacte. Le runtime ouvert ObjectStack en dérive tables, API, UI et outils, puis applique permissions et audit ; ObjectOS prend en charge le déploiement en production et les opérations d’équipe. Moins de code à générer, moins de code à relire.' }, + { title: 'Écrivez l’ontologie, pas du code applicatif', copy: 'Pour les logiciels CRUD et workflow typiques, les agents écrivent la définition ObjectStack compacte. Le runtime ouvert ObjectStack en dérive tables, API, UI et outils, puis applique permissions et audit ; ObjectOS prend en charge le déploiement en production et les opérations d’équipe. Moins de code à générer, moins de code à relire.' }, { title: 'Appliquez la gouvernance au runtime', copy: 'Réutilisez identité d’entreprise, permissions, files de validation et journaux d’audit afin que chaque action d’agent ait des limites définies.' }, ], aiKicker: 'Construction AI et opérations d’agents', @@ -608,7 +612,7 @@ const fr: HomeCopy = { ], securityLink: 'Voir sécurité et gouvernance', insightsKicker: 'Dernières analyses', - insightsTitle: 'Réflexions pratiques sur les logiciels AI-native', + insightsTitle: 'Réflexions pratiques sur les logiciels écrits par l’AI', insightsLink: 'Voir tous les articles', closingKicker: 'Étape suivante', closingTitle: 'Commencez par les données métier que vous connaissez le mieux.', @@ -645,7 +649,7 @@ const ko: HomeCopy = { [positioning.ko.t3[3], '온톨로지를 내보내 오픈소스 ObjectStack에서 실행'], ], imageAlt: '비즈니스 데이터, 애플리케이션과 AI 에이전트를 연결하는 ObjectOS', - imageNoteTitle: '통합 비즈니스 객체 계층', + imageNoteTitle: t2Lead(positioning.ko.t2), imageNote: '애플리케이션, 데이터와 에이전트 연결 중', positioningKicker: positioning.ko.t1, positioningTitle: ['이미 잘 작동하는 시스템은 유지하고,', '에이전트를 위한 거버넌스 런타임을 더하세요.'], @@ -656,7 +660,7 @@ const ko: HomeCopy = { capabilities: [ { title: '에이전트에 비즈니스 모델 제공', copy: '고객, 주문, 장비, 케이스, 승인을 에이전트가 읽고 연결하고 작업할 수 있는 객체로 모델링합니다.' }, { title: '이미 운영 중인 시스템 확장 — 우선 읽기 전용으로', copy: '이미 운영 중인 데이터베이스를 외부 데이터소스로 연합하고 그 테이블을 객체로 모델링합니다. 연합은 기본적으로 읽기 전용이며 아직 초기 단계입니다. 기록 시스템이 계속 행을 쓰고, 쓰기는 객체 단위로 의도적으로 활성화합니다.' }, - { title: '앱 코드가 아니라 메타데이터 생성', copy: '일반적인 CRUD 및 워크플로 소프트웨어에서 에이전트는 압축된 ObjectStack 정의를 작성합니다. 오픈 ObjectStack 런타임이 테이블, API, UI, 도구를 파생하고 권한과 감사를 강제하며, ObjectOS가 프로덕션 배포와 팀 운영을 담당합니다. 생성할 코드도, 검토할 코드도 줄어듭니다.' }, + { title: '앱 코드가 아니라 온톨로지 작성', copy: '일반적인 CRUD 및 워크플로 소프트웨어에서 에이전트는 압축된 ObjectStack 정의를 작성합니다. 오픈 ObjectStack 런타임이 테이블, API, UI, 도구를 파생하고 권한과 감사를 강제하며, ObjectOS가 프로덕션 배포와 팀 운영을 담당합니다. 생성할 코드도, 검토할 코드도 줄어듭니다.' }, { title: '런타임에서 거버넌스 강제', copy: '기업 ID, 권한, 승인 대기열, 감사 로그를 재사용해 모든 에이전트 작업에 정의된 경계를 둡니다.' }, ], aiKicker: 'AI 빌드와 에이전트 운영', @@ -697,7 +701,7 @@ const ko: HomeCopy = { ], securityLink: '보안 및 거버넌스 보기', insightsKicker: '최신 인사이트', - insightsTitle: 'AI-native 소프트웨어에 대한 실무적 관점', + insightsTitle: 'AI가 작성한 소프트웨어에 대한 실무적 관점', insightsLink: '모든 글 보기', closingKicker: '다음 단계', closingTitle: '가장 잘 아는 비즈니스 데이터에서 시작하세요.', diff --git a/src/lib/terms.ts b/src/lib/terms.ts index 29a0030..ef87436 100644 --- a/src/lib/terms.ts +++ b/src/lib/terms.ts @@ -61,8 +61,11 @@ export const childTopics = (parentSlug: string): Term[] => TERMS.filter((t) => t.group === 'topic' && t.parent === parentSlug); export function termDescription(term: Term, locale: Locale): string { + // Traditional Chinese is derived from Simplified (s2twp), the same rule the + // labels follow above — never a hand-kept third copy. + if (locale === 'zh-Hant') return s2t(termDescription(term, 'zh-Hans')); const label = term.label[locale]; - const descriptions: Record> = { + const descriptions: Record, Record> = { en: { topic: `Articles about ${label}, with practical notes on executable business ontologies, governed data, application development, and agent workflows.`, solution: `Practical guidance for ${label} scenarios, including data models, workflows, permissions, integrations, and AI agent patterns for enterprise teams.`, @@ -70,45 +73,39 @@ export function termDescription(term: Term, locale: Locale): string { industry: `Articles for ${label} teams on connecting existing systems, business data, workflows, and AI agents without replacing core platforms.`, }, 'zh-Hans': { - topic: `围绕${label}的文章，关注 AI-native 企业软件、受控数据、应用搭建和 Agent 工作流的实践。`, + topic: `围绕${label}的文章，关注可执行业务本体、受治理的数据、应用搭建和 Agent 工作流的实践。`, solution: `关于${label}场景的实践思考，覆盖数据模型、流程、权限、集成以及企业 AI Agent 的设计方式。`, - role: `面向${label}的文章，讨论如何用 ObjectOS 构建、运行和治理 AI-native 业务应用。`, + role: `面向${label}的文章，讨论如何用 ObjectOS 构建、运行和治理 AI 编写的业务应用。`, industry: `面向${label}团队的文章，讨论如何连接现有系统、业务数据、流程与 AI Agent，而不是替换核心平台。`, }, - 'zh-Hant': { - topic: `圍繞${label}的文章，關注 AI-native 企業軟體、受控資料、應用搭建和 Agent 工作流的實踐。`, - solution: `關於${label}場景的實踐思考，覆蓋資料模型、流程、權限、整合以及企業 AI Agent 的設計方式。`, - role: `面向${label}的文章，討論如何用 ObjectOS 構建、執行和治理 AI-native 業務應用。`, - industry: `面向${label}團隊的文章，討論如何連線現有系統、業務資料、流程與 AI Agent，而不是替換核心平臺。`, - }, ja: { - topic: `${label}に関する記事。AI-native な企業ソフトウェア、管理されたデータ、アプリ開発、エージェントワークフローを実践的に扱います。`, + topic: `${label}に関する記事。実行可能なビジネスオントロジー、管理されたデータ、アプリ開発、エージェントワークフローを実践的に扱います。`, solution: `${label}のシナリオについて、データモデル、ワークフロー、権限、連携、企業向け AI エージェントの設計を扱います。`, - role: `${label}向けに、ObjectOS で AI-native な業務アプリを構築、運用、統制する方法をまとめます。`, + role: `${label}向けに、ObjectOS で AI が書く業務アプリを構築、運用、統制する方法をまとめます。`, industry: `${label}チーム向けに、既存システム、業務データ、ワークフロー、AI エージェントをコアプラットフォームの置き換えなしにつなぐ方法を扱います。`, }, de: { - topic: `Artikel zu ${label}: praktische Gedanken zu AI-nativer Unternehmenssoftware, kontrollierten Daten, App-Entwicklung und Agent-Workflows.`, + topic: `Artikel zu ${label}: praktische Gedanken zu ausführbaren Geschäftsontologien, kontrollierten Daten, App-Entwicklung und Agent-Workflows.`, solution: `Praxiswissen zu ${label}: Datenmodelle, Workflows, Berechtigungen, Integrationen und AI-Agent-Muster für Unternehmen.`, - role: `Artikel für ${label} über Aufbau, Betrieb und Governance AI-nativer Geschäftsanwendungen mit ObjectOS.`, + role: `Artikel für ${label} über Aufbau, Betrieb und Governance AI-geschriebener Geschäftsanwendungen mit ObjectOS.`, industry: `Artikel für Teams in ${label}: bestehende Systeme, Geschäftsdaten, Workflows und AI Agents verbinden, ohne Kernplattformen zu ersetzen.`, }, es: { - topic: `Artículos sobre ${label}, con notas prácticas sobre software empresarial AI-native, datos gobernados, desarrollo de apps y flujos con agentes.`, + topic: `Artículos sobre ${label}, con notas prácticas sobre ontologías de negocio ejecutables, datos gobernados, desarrollo de apps y flujos con agentes.`, solution: `Ideas prácticas para ${label}: modelos de datos, workflows, permisos, integraciones y patrones de agentes AI para equipos empresariales.`, - role: `Artículos para ${label} sobre construir, operar y gobernar aplicaciones de negocio AI-native con ObjectOS.`, + role: `Artículos para ${label} sobre construir, operar y gobernar aplicaciones de negocio escritas por AI con ObjectOS.`, industry: `Artículos para equipos de ${label} sobre conectar sistemas existentes, datos de negocio, workflows y agentes AI sin reemplazar plataformas centrales.`, }, fr: { - topic: `Articles sur ${label}, avec des notes pratiques sur les logiciels d’entreprise AI-native, les données gouvernées, les applications et les workflows d’agents.`, + topic: `Articles sur ${label}, avec des notes pratiques sur les ontologies métier exécutables, les données gouvernées, les applications et les workflows d’agents.`, solution: `Réflexions pratiques sur ${label} : modèles de données, workflows, permissions, intégrations et agents AI pour les équipes d’entreprise.`, - role: `Articles pour ${label} sur la construction, l’exploitation et la gouvernance d’applications métier AI-native avec ObjectOS.`, + role: `Articles pour ${label} sur la construction, l’exploitation et la gouvernance d’applications métier écrites par l’AI avec ObjectOS.`, industry: `Articles pour les équipes ${label} sur la connexion des systèmes existants, données métier, workflows et agents AI sans remplacer les plateformes centrales.`, }, ko: { - topic: `${label}에 관한 글입니다. AI-native 엔터프라이즈 소프트웨어, 관리되는 데이터, 앱 개발, 에이전트 워크플로를 실무 관점에서 다룹니다.`, + topic: `${label}에 관한 글입니다. 실행 가능한 비즈니스 온톨로지, 관리되는 데이터, 앱 개발, 에이전트 워크플로를 실무 관점에서 다룹니다.`, solution: `${label} 시나리오에 대한 실무 관점입니다. 데이터 모델, 워크플로, 권한, 통합, 기업용 AI 에이전트 패턴을 다룹니다.`, - role: `${label}를 위해 ObjectOS로 AI-native 비즈니스 애플리케이션을 구축, 운영, 거버넌스하는 방법을 다룹니다.`, + role: `${label}를 위해 ObjectOS로 AI가 작성한 비즈니스 애플리케이션을 구축, 운영, 거버넌스하는 방법을 다룹니다.`, industry: `${label} 팀을 위해 기존 시스템, 비즈니스 데이터, 워크플로, AI 에이전트를 핵심 플랫폼 교체 없이 연결하는 방법을 다룹니다.`, }, }; diff --git a/src/pages/llms.txt.ts b/src/pages/llms.txt.ts index ff0e1f9..b3d6fa4 100644 --- a/src/pages/llms.txt.ts +++ b/src/pages/llms.txt.ts @@ -69,8 +69,8 @@ export const GET: APIRoute = async ({ site }) => { '', '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.', + '- **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 in the sense the next term defines: the ObjectStack runtime derives the database, REST API, screens, and MCP tools from it and enforces permissions and audit on every call.', + '- **Executable business ontology**: the definition of a business that a runtime runs — objects and fields, relations, actions, permissions, flows, and agent and tool definitions — authored as typed metadata, validated, and then executed, so that the database, API, screens, and agent tools are derived from it rather than described by it. Four boundaries come with the word. It is executable, not a knowledge-representation ontology: no inheritance, no axioms, no reasoner — the definition is validated rather than reasoned over. It is not a semantic layer over your existing systems: it is the system, and federating an external datasource is read-only by default and early. Views, dashboards, apps, and translations are projections of the ontology, not part of it. And code does not disappear: it moves into the runtime, as hooks, action bodies, CEL, and constrained JSX. What makes it worth writing this way 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', From 9242de39a65735a00cb65427769ece6f0df9283a Mon Sep 17 00:00:00 2001 From: Claude Date: Fri, 16 Oct 2026 07:23:12 +0000 Subject: [PATCH 2/4] content(positioning): glossary ontology links the /ontology/ and /compare/ pages; llms.txt Articles line leaves "AI-native" Patch round on #233's review: `pageSlugs` of the `ontology` term (en, zh-Hans) now lead with the two pages #258 added on main; the llms.txt Articles entry describes the blog in the ontology framing. Co-Authored-By: Claude Claude-Session: https://claude.ai/code/session_017GeNDQH7E5S2rX8ajVAPxv --- content/glossary/en/ontology.ts | 2 +- content/glossary/zh-Hans/ontology.ts | 2 +- src/pages/llms.txt.ts | 2 +- 3 files changed, 3 insertions(+), 3 deletions(-) diff --git a/content/glossary/en/ontology.ts b/content/glossary/en/ontology.ts index 0b352a3..9a7a26d 100644 --- a/content/glossary/en/ontology.ts +++ b/content/glossary/en/ontology.ts @@ -33,7 +33,7 @@ const term = { 'enterprise-ontology-platform-comparison', 'objectos-action-tools', ], - pageSlugs: ['data-modeling', 'app-ui', 'permissions', 'mcp', 'agent-developer', 'platform', 'ai'], + pageSlugs: ['ontology', 'compare', 'data-modeling', 'app-ui', 'permissions', 'mcp', 'agent-developer', 'platform', 'ai'], } satisfies GlossaryTerm; export default term; diff --git a/content/glossary/zh-Hans/ontology.ts b/content/glossary/zh-Hans/ontology.ts index 66f3bff..c80a149 100644 --- a/content/glossary/zh-Hans/ontology.ts +++ b/content/glossary/zh-Hans/ontology.ts @@ -33,7 +33,7 @@ const term = { 'enterprise-ontology-platform-comparison', 'objectos-action-tools', ], - pageSlugs: ['data-modeling', 'app-ui', 'permissions', 'mcp', 'agent-developer', 'platform', 'ai'], + pageSlugs: ['ontology', 'compare', 'data-modeling', 'app-ui', 'permissions', 'mcp', 'agent-developer', 'platform', 'ai'], } satisfies GlossaryTerm; export default term; diff --git a/src/pages/llms.txt.ts b/src/pages/llms.txt.ts index b3d6fa4..c5ca931 100644 --- a/src/pages/llms.txt.ts +++ b/src/pages/llms.txt.ts @@ -92,7 +92,7 @@ export const GET: APIRoute = async ({ site }) => { `- [Security](${absoluteUrl(site, securityPath('en'))}): Data residency, permissions, approvals, audit logs, and the ObjectOS Enterprise self-managed deployment boundary.`, `- [Pricing](${absoluteUrl(site, pricingPath('en'))}): Open-source ObjectStack, the ObjectOS Cloud plans (Free, Team, Business), and self-managed ObjectOS Enterprise, from its single-node Business Self-Managed entry up.`, `- [Glossary](${absoluteUrl(site, glossaryIndexPath('en'))}): One-sentence definitions of the vocabulary this site uses, each linked to the pages and articles that apply it.`, - `- [Articles](${absoluteUrl(site, blogPath('en'))}): Practical writing on AI-native software, enterprise AI agents, integration, modernization, and governance.`, + `- [Articles](${absoluteUrl(site, blogPath('en'))}): Practical writing on executable business ontologies and AI-written software, enterprise AI agents, integration, modernization, and governance.`, `- [Documentation](https://docs.objectos.ai/): Product and developer documentation.`, '', '## Glossary', From 39ab7291e8d97ab8ab62bc082a2ee6423c99aad6 Mon Sep 17 00:00:00 2001 From: Claude Date: Fri, 16 Oct 2026 07:33:12 +0000 Subject: [PATCH 3/4] content(positioning): shorten the AI-native cluster H1 to sibling length; agent-developer hero teaches the agent to write the ontology Patch round 2 on #233's review. The cluster title doubled as the H1 and ran five lines on a laptop viewport; it is now the search term plus the answer in seven words, the definition staying in the description and lead. The agent-developer hero's second sentence leaves "the target format" for the ontology framing, en authored and zh-Hans re-derived. Co-Authored-By: Claude Claude-Session: https://claude.ai/code/session_017GeNDQH7E5S2rX8ajVAPxv --- content/pages/en/agent-developer.ts | 2 +- content/pages/zh-Hans/agent-developer.ts | 2 +- src/lib/clusters.ts | 2 +- 3 files changed, 3 insertions(+), 3 deletions(-) diff --git a/content/pages/en/agent-developer.ts b/content/pages/en/agent-developer.ts index 1f4ac3f..08f3529 100644 --- a/content/pages/en/agent-developer.ts +++ b/content/pages/en/agent-developer.ts @@ -10,7 +10,7 @@ const page = { description: 'The README path for a coding agent: npm create objectstack@latest writes an AGENTS.md, the agent writes typed metadata, os validate rejects what would fail at runtime, and npx os dev --ui renders the app for review.', eyebrow: 'Agent developer', - heroTitle: 'Do not teach every developer to hand-write apps. Teach your agent the target format.', + heroTitle: 'Do not teach every developer to hand-write apps. Teach your agent to write the ontology.', lead: `${p.t2} The ontology is what the agent writes — ${p.t3[1]}, in the README’s four promises — and you are the reviewer: the scaffolder writes an AGENTS.md so the agent starts with the protocol’s rules loaded, Strict TypeScript, Zod schemas, and os validate reject invalid output before it reaches the runtime, and the whole app stays small enough for AI to hold whole.`, primary: { label: 'Follow the README path', href: 'https://github.com/objectstack-ai/objectstack#try-it-in-five-minutes' }, diff --git a/content/pages/zh-Hans/agent-developer.ts b/content/pages/zh-Hans/agent-developer.ts index e5fcb11..328b181 100644 --- a/content/pages/zh-Hans/agent-developer.ts +++ b/content/pages/zh-Hans/agent-developer.ts @@ -10,7 +10,7 @@ const page = { description: '编码 Agent 的 README 路径：npm create objectstack@latest 写入 AGENTS.md，Agent 编写类型化元数据，os validate 拒掉运行时会失败的东西，npx os dev --ui 把应用渲染出来供人审阅。', eyebrow: 'Agent 开发指南', - heroTitle: '别教每个开发者手写应用。教你的 Agent 目标格式。', + heroTitle: '别教每个开发者手写应用。教你的 Agent 写本体。', lead: `${p.t2}Agent 写的就是本体——四个承诺里的「${p.t3[1]}」——你是审阅者：脚手架写入 AGENTS.md，让 Agent 一开始就带着协议规则；Strict TypeScript、Zod schema 与 os validate 会在无效输出进入运行时前将其拒掉；整个应用小到 AI 能整体装下。`, primary: { label: '照 README 路径走', href: 'https://github.com/objectstack-ai/objectstack#try-it-in-five-minutes' }, diff --git a/src/lib/clusters.ts b/src/lib/clusters.ts index d7e6b51..53af340 100644 --- a/src/lib/clusters.ts +++ b/src/lib/clusters.ts @@ -27,7 +27,7 @@ export const CLUSTERS: Cluster[] = [ // page and llms.txt link this page in every locale — but the copy defines // the product by the ontology, not by the category. slug: 'ai-native-app-platform', - title: 'What Is an AI-Native App Platform? One Executable Business Ontology', + title: 'AI-Native App Platform: One Executable Ontology', shortTitle: 'Executable business ontology', description: 'An AI-native app platform, defined the way ObjectStack defines it: one executable business ontology that AI writes, an open runtime runs, agents operate, and you own — how that differs from low-code and from AI code generation, and where ObjectOS fits.', From bb415e7d74e405b2ff4758574f368cab1e7b39f6 Mon Sep 17 00:00:00 2001 From: Claude Date: Fri, 16 Oct 2026 07:37:02 +0000 Subject: [PATCH 4/4] =?UTF-8?q?content(positioning):=20cluster=20H1=20"AI-?= =?UTF-8?q?Native=20App=20Platform:=20An=20Ontology=20You=20Run"=20?= =?UTF-8?q?=E2=80=94=20three=20lines=20at=20laptop=20widths?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Measured in the live page before choosing: "One Executable Ontology" still wrapped to four lines (344px) at 1366, 1440 and 1920 because "Executable Ontology" cannot share a line in the hero column; this title renders three lines (258px), equal to the sibling clusters, at all three widths. Co-Authored-By: Claude Claude-Session: https://claude.ai/code/session_017GeNDQH7E5S2rX8ajVAPxv --- src/lib/clusters.ts | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/lib/clusters.ts b/src/lib/clusters.ts index 53af340..e2fd068 100644 --- a/src/lib/clusters.ts +++ b/src/lib/clusters.ts @@ -27,7 +27,7 @@ export const CLUSTERS: Cluster[] = [ // page and llms.txt link this page in every locale — but the copy defines // the product by the ontology, not by the category. slug: 'ai-native-app-platform', - title: 'AI-Native App Platform: One Executable Ontology', + title: 'AI-Native App Platform: An Ontology You Run', shortTitle: 'Executable business ontology', description: 'An AI-native app platform, defined the way ObjectStack defines it: one executable business ontology that AI writes, an open runtime runs, agents operate, and you own — how that differs from low-code and from AI code generation, and where ObjectOS fits.',