Recently, OpenClaw has been gaining rapid traction in the developer community. Its rise highlights a broader shift: AI is evolving from "able to chat" to "able to act."

Agents are beginning to operate systems, invoke tools, and access databases. They are no longer limited to answering questions—they are executing tasks on behalf of users.

However, as Agents start interacting with database interfaces, a fundamental question emerges:

Do Agents truly understand databases?

Invocation ≠ Understanding: The Cognitive Gap Agents Face

As Agents become a new software interaction paradigm, the question is no longer whether they can invoke a database. The real challenge is whether they possess domain cognition.

Take Apache IoTDB as an example. For an Agent to effectively assist users, it must understand far more than API syntax. At minimum, it needs knowledge of:

• The differences between the tree model and the table model

• Common pitfalls in time-series data modeling

• Optimization strategies for high-throughput writes and queries

• The design boundaries and applicable scenarios of Apache TsFile

• Trade-offs between consistency and performance in industrial workloads

This type of domain expertise is not inherently embedded in general-purpose LLM(large language models). Without it, even an Agent that successfully calls IoTDB APIs may:

• Misinterpret data modeling and generate logically incorrect code

• Provide generic, non-actionable optimization advice

• Confuse data models and trigger runtime errors

• Produce "technical hallucinations" that sound plausible but are fundamentally wrong

IoTDB Skills: Giving Agents a Domain Knowledge Foundation

To address this gap, we recently open-sourced two core skill sets: IoTDB Skill and TsFile Skill

Project website: https://github.com/timecholab/timecho-skills

Skills (Timecho): AI assistant capabilities for working with Apache IoTDB and Apache TsFile.

Here, Skills are not traditional feature modules. Instead, they represent a structured domain knowledge packaging approach for AI systems.

These Skills distill real-world engineering experience with IoTDB and TsFile into reusable, machine-interpretable capability modules, including:

• Core conceptual boundaries of time-series databases

• Common usage scenarios and anti-patterns

• Recommended analytical approaches for specific problems

• Guardrails designed to reduce technical hallucinations

In essence, IoTDB Skills attempt to answer a key question:

If an Agent is expected to help users succeed with IoTDB, what foundational knowledge must it possess?

This is not merely a product feature—it is a community-level exploration into how AI can move beyond "API invocation without understanding" toward accurate domain reasoning in time-series systems.

Beyond Understanding: Native Database Intelligence

If IoTDB Skills address how Agents understand databases, another question follows: How do Agents connect to databases in the first place?

We previously introduced MCP capabilities:

• MCP solves how Agents securely and properly connect to databases

• Skills address whether Agents truly understand domain logic

They operate at different layers and are complementary:

• MCP = Connectivity layer → enables safe database access

• Skills = Cognition layer → enables correct domain reasoning

On top of these, IoTDB's ongoing evolution is exploring a third dimension:

• Intelligence layer—represented by capabilities such as AINode, enabling built-in reasoning, analytics, and forecasting within the database itself

From connectivity, to cognition, to built-in intelligence—these form the three critical upgrade paths for databases in the Agent era.

Within IoTDB's roadmap, this direction is already taking shape through:

• Covariate forecasting to improve time-series trend prediction

• Built-in time-series foundation models(Timer) to lower the barrier to intelligent analytics

• The extensible AINode architecture providing infrastructure for native intelligence

These are not simply "AI add-ons." They embed analytical and predictive intelligence directly into the database engine, unifying storage, computation, and intelligence to support the next-generation Agent interaction model.

The overview of IoTDB AI ability

The Database Role Is Being Redefined in the Agent Era

Not every system will become an Agent. But every system will need to be understood correctly by Agents.

OpenClaw's popularity is just one signal of the broader Agent wave. As Agents become a core component of the software ecosystem, the role of databases is being fundamentally reshaped.

In the future, every database must adapt to requirements of an Agent-driven ecosystem:

• Be correctly understood by Agents, not just mechanically invoked

• Provide structured domain memory to support Agent decision-making

• Possess native intelligent analytics, evolving from data storage to an intelligent data foundation

IoTDB and TsFile Skills represent an early exploration toward machine-understandable databases, while covariate forecasting and AINode point toward native intelligence within the database.

These efforts are still in early stages—but they converge on a clear direction:

In the Agent era, domain knowledge crystallization and intelligent data infrastructure will become core competitive advantages for databases.

The Agent era is just beginning—and the evolution of databases is already underway.

If you are interested in AI, Agents, IoTDB, or TsFile, you are welcome to join the community discussion and contribute.