Building an Agent System Solution on OceanBase & LangChain to Get Agents into Production Fast

On May 30, the OceanBase community, together with the LangChain China community, held a meetup in Shanghai. LangChain & OceanBase community ambassador “Canghai Jiusu” officially unveiled AgentSeek — an agent system solution built on OceanBase and LangChain.

1. What Is AgentSeek? And What Is It Not?

First, let’s be clear: AgentSeek is not a new framework. There are already many excellent frameworks on the market — for example, LangChain, LangGraph, and Deep Agents from the LangChain community offer very comprehensive capabilities, more than enough for most scenarios. Products like OpenClaw and Hermes also benchmark against the LangChain ecosystem from different angles.

So what exactly is AgentSeek? It’s an “agent engineering toolkit” — a set of tools and libraries that help developers quickly build an agent flywheel with data-loop capabilities.

2. What Is Agent Engineering? From Concept to Implementation

The concept of “agent engineering” was put forward by LangChain at its first global developer conference last May. Although it was briefly overshadowed by the “context engineering” concept proposed by Andrej Karpathy, by the second conference in mid-May this year, LangChain had already turned it into a commercial-grade product and platform. As an industry leader (valued at roughly 10 billion RMB, Series B), why is LangChain pushing agent engineering? Its core idea is an analogy to software engineering: agent development isn’t just about building features, but involves a complete engineering set of activities — development, testing, evaluation, launch, and monitoring.

The focus of engineering isn’t the development process itself, but the idea that “going live is the starting point for learning.” LangChain emphasizes getting agents into production as fast as possible, generating production data and forming a data loop.

3. Is “Launch and Continuous Learning” Alone Enough?

Last year it might have been enough, but today it’s far from it. The LangChain team re-clarified this year: Agent = Model + Harness. That is, every component outside the model can be called the Harness. Stripped back to basics, building an agent is just a model, a Harness, and a loop.

As the boundaries of understanding expand, the Harness has more and more factors to consider. A recent LangChain article subdivides them into 16 categories, which can be grouped into four major ones: file system, memory and continuous learning, context engineering, and long-running tasks.

Over the course of a year, LangChain turned agent engineering from concept into a platform, and on May 13 this year, at its second developer conference, officially launched the LangSmith platform. The platform unveiled nine core products in three categories: accelerating the development lifecycle, strengthening infrastructure governance, and enhancing observability and governance.

The most striking part is that LangChain “quietly” built its own database. This strongly validates the value of partnering with database vendors like OceanBase. The focus of competition is no longer concept or framework; rather, commercializing agent development must be a complete, engineered loop — and the core of that loop is the data loop.

4. The Open-Source Ecosystem’s Gap-Filling and AgentSeek’s Mission

So we propose: “To build production agents, we first have to help everyone get to production.” This echoes LangChain’s “Shipping is how you learn.” We partnered with the OceanBase open-source community to try filling the gaps through open-source projects, focusing on the key links of agent engineering and the Harness.

Anatomy of the AgentSeek Architecture

As an agent engineering toolkit, AgentSeek aims to complete the following five-layer architecture (not all built in-house, but fusing the open-source ecosystem):

1. Data Foundation: in partnership with OceanBase, providing support from the edge (seekdb) to the cloud, compatible with the MySQL protocol for the convenience of domestic users.
2. Context Semantic Layer: uniformly manages memory, RAG content, tool-call results, and more, with self-evolution, retrievability, and evidence-chain traceability.
3. Runtime Layer: the core layer, turning local applications into services, supporting deployment methods such as Docker and K8S.
4. Gateway Layer: connects to IM tools such as DingTalk, Feishu, Slack, and Discord, serving as the agent’s entry point.
5. Application Layer: builds concrete agent applications on top of the runtime layer and standard protocols.

AgentSeek’s Core Pillars

1. AgentSeek API: provides a lightweight reference Server implementation compatible with the Agent Protocol, supporting MCP, streaming output, A2A, and more.
2. SeekContext: uniformly manages agent context on top of memory, supporting content layering, traceability, and self-evolution (including the introverted and divergent Dream systems).
3. OceanBase seekdb: a lightweight AI-native database with MySQL-compatible ecosystem capabilities, solving the LangChain ecosystem’s strong dependence on PostgreSQL.

All this work integrates natively with the LangChain ecosystem and comes with out-of-the-box observability.

5. Summary and Outlook

LangSmith is the flywheel LangChain offers enterprises; AgentSeek is the flywheel for community developers, and we hope it can save you a stretch of road — the rest of the way, let’s walk it together. AgentSeek currently focuses on a few core pillars, and plans to integrate more open-source Sandboxes and Gateways in the future, as well as provide an open-source observability solution.

All mentioned projects are already open-source — you’re welcome to try them out and contribute PRs/Issues! Please also keep an eye on the LangChain ecosystem; it remains one of the best paths for quickly learning and productizing agent systems.