bubseek — Turning an Agent's Footprints into Team Insights
Building an Agent that everyone loves is hard, but helping others build an Agent that he/she/it loves is pretty great too~
🔍 bubseek’s “memory treasury” is guarded by seekdb! If you also want to find a reliable data steward for your own Agent, come and explore https://github.com/oceanbase/seekdb—you might just find a pleasant surprise~
What Is bub?
bub is a framework, but what does “framework” mean? I think it might be: a common shape for an Agent—a relatively stable baseline micro-framework that supports deep, personalized customization. This easily brings to mind the MCV (Mobile Construction Vehicle) in Command & Conquer: fold it up and it can drive around; unfold it and it can build. bub is that MCV—not the base itself, but the thing that makes the base possible.
This Agent kernel needs to be stable enough and easy enough to understand, with quality guaranteed by the maintainers. Feature plugins, meanwhile, extend it through open interfaces—you can vibe-code them however you like, or even let the Agent generate the code for a feature requirement itself.
The currently popular OpenClaw is essentially impossible to truly deploy inside enterprises, so bub separates out the features an Agent doesn’t need, turning it into an architecture of a carefully designed lightweight kernel + freely vibe-coded feature plugins.
bub is a hook-first AI framework. The core stays lean and extends functionality through hooks and skills. Its architecture is very elegant: the AgentLoop abstraction, the Tape memory system, and the Skills engine—each module is just right. The core philosophy is a deterministic, one-way data flow of “route → model → tools → memory.”
Every major part of the framework’s pipeline is easy to customize. We want bub to be an Agent with no preferences—all preferences come from the user—so distributions can be made conveniently.
A hook is bub’s extension point. The framework itself is just an empty shell; all functionality is implemented through hook plugins, including the built-in features themselves.
The editor’s guess: this is probably the origin of the bub project logo shown at the beginning of the article.
You’re welcome to follow the OceanBase community WeChat account “Lao Ji’s Tech Talk”—we’ll keep updating you with technical content related to #Data and #AI!
What Is bubseek?
Simply put, bubseek is a self-driven insight Agent. Built on bub and OceanBase seekdb, it accepts prompts and turns data into readable, shareable insights.
More precisely, based on a task’s needs, it can autonomously connect to data sources, define and customize visualization views for them, perform analysis actions, and submit the corresponding analysis reports. No lengthy scheduling, no cross-department coordination—just tell it what you want, and leave the rest to bubseek.
How can we use Agents to further satisfy enterprises’ customized needs for all kinds of data consumption? And when an Agent’s footprints spread across group chats and task flows, how do we turn these scattered traces into insights the team can share and reuse? This is the question bubseek aims to answer.
bubseek uses the hook mechanism mentioned above to register OceanBase/seekdb with bub as the Agent’s backend data storage component—without changing bub’s source code, only hooking in.
Of course, like bub, bubseek can also be viewed as a framework that can become whatever you want it to be.
As for how it becomes that, everyone will have their own expectations and understanding of bubseek. You’re welcome to try various models, prompt engineering, and personification techniques, or even modify its code, until it reaches the goal you want. If you need a starting point to begin exploring Agents, then perhaps bubseek—like bub—is a good choice.
bubseek’s Technical Architecture and Current State
bubseek accepts prompts, autonomously connects to data sources based on task needs, defines and customizes visualization views, performs analysis actions, and submits analysis reports. It is responsible for “consuming” data—analyzing, distilling, and outputting insights.
bubseek is built on bub and seekdb:
- bub is an Agent framework. It defines the common shape of an Agent: bounded, evidence-backed, and handoff-able. Its tape design completely records every thought, every tool call, and every result of the Agent.
- seekdb is an embedded database. Purpose-built for AI-era workloads, it natively supports capabilities like vector embeddings and RAG, providing better support for “turning data into insights.”
This architecture supports the two capabilities mentioned earlier: externally, bubseek acts as an Agent consuming data to serve business needs; internally, its own footprints in turn become objects of analysis, feeding back into the team’s understanding.
bubseek is still at a relatively early stage, but we’ve already validated and run through the basic business workflow: from data ingestion, to seekdb storage, to Agent analysis generating insights.
That said, this may also be a good time for “deep customization.”
Meeting Customized Data Needs
Enterprises’ internal data consumption needs are often diverse, fragmented, and constantly changing. Operations wants to watch trends, product wants to track metrics, the boss wants a daily report—the traditional way is to file a request, wait for scheduling, and go live: long cycle, high cost.
bubseek wants to do it differently, letting these small, specific pieces of data be seen.
Turn Requirements into Prompts
In bubseek, you don’t need to write complex queries or draw tedious reports. You just tell it what you want:
- “Build me a dashboard that tracks new projects in the AI field this week, updated daily.”
- “Analyze why vllm is suddenly trending and produce a brief.”
- “Show me the technical topics the team discussed most in the past month.”
bubseek receives the prompt and does the rest itself: connecting to data sources (GitHub, Slack, internal systems…), defining views, running analysis, and generating reports.
No Scheduling, Only Iteration
Because the whole process is Agent-driven, the response speed for a request changes from “weekly scheduling” or “allocating person-days” to “instant response.” Not satisfied? Change the prompt and try again. Want a new dimension? Just add a sentence. Data consumption is no longer a heavyweight “file a request, wait for delivery” process but a lightweight conversation.
Turning the Agent’s Footprints into Team Insights
When the team starts using bubseek, it generates a large amount of data on its own—every interaction, every query, every report is stored in seekdb in the form of a tape. This data is itself a mine of insights.
Analyzing the Agent Is Analyzing the Team
bubseek can analyze itself just like any other data source:
- Which types of queries are most common?—reflecting what the team cares about most
- Which tasks fail frequently?—reflecting the Agent’s capability boundaries, and possibly the business’s pain points
- Which needs are repeatedly mentioned but unmet?—reflecting product opportunities
This isn’t traditional “observability” (looking at system health) but a deeper layer of “understandability”—using the Agent’s footprints to understand what the team is thinking, doing, and getting stuck on.
No Dedicated Analytics Tool Needed
Because all the data is in seekdb, analysis is itself bubseek’s job. Want to understand the team’s movements over the past week? Just ask bubseek. It queries its own tape and gives you a report.
This forms a closed loop: bubseek serves the team and produces data; this data is in turn analyzed by bubseek, feeding back into the team’s understanding of its own collaboration.
bubseek’s Key Features
Next, let me introduce several of bubseek’s key features.
Multi-Channel Support
An Agent needs entry points to receive requests. bubseek has five common instant-messaging channels built in: Feishu, DingTalk, WeChat, Discord, and Telegram. Just configure the corresponding environment variables after installation to use them—no additional development required. These channels follow bub’s channel extension spec, making it easy to develop your own extensions or bring in other third-party implementations.
There’s also a Web entry point: the marimo channel. After starting it, visit http://127.0.0.1:2718. Beyond a basic conversation interface, it also includes simple data analysis visualization examples and some dashboards for presenting internal service data.
Lightweight Data Consumption
After the Agent receives a request, it executes the task and outputs the result.
Enterprises’ internal data consumption needs are often fragmented: operations wants to watch trends, product wants to track metrics, engineering wants to follow open-source developments. The traditional way is to file a request, wait for scheduling, and ship a BI report. Long cycle, high cost. Small needs don’t make the queue, and big needs never get finished.
bubseek wants to do it differently: no need to deploy a standalone BI system—a notebook can carry the dashboards, charts, and analysis scripts. Not satisfied? Change a parameter and try again. Want a new dimension? Just add a sentence. Response speed goes from “weekly scheduling” to “instant iteration.”
marimo notebook: marimo is a reactive Python notebook. bubseek ships with two templates, dashboard.py and index.py. Users can add their own notebooks under the insights/ directory. The Agent can dynamically generate or modify notebooks based on needs, turning data consumption into conversation rather than scheduling.
GitHub repository cards: the built-in github-repo-cards skill. Given an org/repo, it generates a card containing basic information, star trends, and contributors; or it scrapes GitHub trending to generate a trend list. It outputs SVG and PNG formats. Turning data on GitHub into shareable images is a concrete example of a data consumption scenario.
Of course, if these tools aren’t needed, they can also be quickly removed by detaching the hooks.
Scheduled tasks: the built-in bubseek-schedule. The Agent can manage scheduled tasks via schedule.add, schedule.list, and schedule.remove, supporting cron expressions, interval triggers, and delayed triggers. When a user says “remind me to check the data every day at 9 a.m.,” the Agent can create the corresponding scheduled task. Recurring data needs can also be satisfied instantly.
Intrinsic Observability
During execution, the Agent produces a large amount of data. This data isn’t a byproduct but material for understanding the Agent and the team.
Traditional observability is bolted on: deploy a monitoring system, collect metrics, watch dashboards. The Agent’s observability can be intrinsic: the Agent naturally produces data while running, this data is stored in seekdb, and it can be analyzed by the Agent itself.
tape: bub’s core design. It completely records the channel’s chat sessions and every thought, tool call, and result of the Agent. These records are persisted in the form of tapes and are tamper-proof. The tape is itself part of the Agent’s work, not a log appended after the fact. All data is persisted to seekdb, so later you can have the Agent analyze the tape to understand: which questions are mentioned frequently? Which tasks fail often? What does the team care about most?
marimo dashboard: bubseek ships with dashboard templates for displaying the Agent’s runtime data. Tape records, conversation history, and task status can all be viewed in the marimo interface. There’s no need to deploy a standalone monitoring system—the Agent’s footprints are themselves browsable, queryable data.
This forms a closed loop: the Agent serves the team and produces data; this data is stored in seekdb, visualized via dashboards or analyzed by the Agent, feeding back into the team’s understanding of its own collaboration.
Of course, users can also interact with bubseek via natural language, having it analyze any Agent data stored in seekdb and generate dashboards.
For example:
Or:
The generated dashboard will look something like:
A Unified Data Foundation
All of the records above are stored in seekdb.
seekdb is OceanBase’s lightweight edition for AI scenarios. It natively supports multi-path retrieval capabilities such as SQL, vector, and full-text search, and provides hybrid search strategies, able to adapt to diverse data processing and consumption needs. bubseek connects through the pyobvector driver and includes compatibility handling tailored to OceanBase’s characteristics.
Configuration:
1 | BUB_TAPESTORE_SQLALCHEMY_URL=mysql+oceanbase://user:pass@host:port/database |
One database carries three types of data: tapes, sessions, and tasks. And if seekdb can’t keep up with business growth, you can seamlessly switch to a battle-tested distributed database like OceanBase.
Quick Start
Deploy seekdb
For the steps to deploy seekdb, see: https://docs.seekdb.ai/seekdb/zh-CN/deploy-overview.
Using the documentation above, you can quickly deploy seekdb in server mode directly in the local Linux, Mac, or Windows environment you’re using.
The minimum CPU requirement is 1 core, and the minimum available memory is 2G.
Deploy bubseek
1 | git clone https://github.com/ob-labs/bubseek.git |
Configure seekdb:
1 | export BUB_TAPESTORE_SQLALCHEMY_URL=mysql+oceanbase://root@127.0.0.1:2881/bubseek |
Note: you also need to configure the API KEY for a model suitable for the Agent to use. Reference: https://github.com/ob-labs/bubseek
Final Thoughts
The original intent behind building bubseek wasn’t to create a “big and comprehensive” data platform or a general-purpose Agent—there are already far too many of those on the market.
What we wanted to build is an Agent that can truly understand itself, understand the team, and understand the data. When Agents become collaborating members of a team, their footprints shouldn’t be scattered everywhere, ignored. Within these traces lie the team’s knowledge, the bottlenecks in processes, and even the Agent’s own capability boundaries.
More importantly, enterprises’ internal needs for data consumption are diverse and customized. The traditional way is to file a request, wait for scheduling, and go live: long cycle, high cost. bubseek wants to offer another possibility: tell the Agent what you want, and it goes off to connect to data, define views, run analysis, and output reports.
No scheduling—only iteration. Everything happens naturally.
bubseek 0.1.0 is an attempt to package bub’s capabilities into a distribution oriented toward the domain of data consumption, while also validating the feasibility of seekdb as a data foundation for Agents.
It’s not yet mature. But the basic workflow already runs end to end: from receiving requests at the entry point, to executing and outputting results, to storing records in seekdb.
It will continue to iterate going forward.
References
- GitHub - ob-labs/bubseek: https://github.com/ob-labs/bubseek
- GitHub - OceanBase/seekdb: https://github.com/oceanbase/seekdb
- GitHub - bubbuild/bub: https://github.com/bubbuild/bub
- The unified context model behind bub: https://tape.systems