Intrinsic Observability: Build an Insight Agent on seekdb

When Your Agent Learns to Watch Itself

AI agents are moving from side projects into real team workflows. They join group chats, handle scheduled tasks, triage tickets, summarize meetings. As adoption scales, a new problem emerges: nobody knows what the agent actually did.

Traditional observability assumes you're monitoring a service — collect metrics, emit logs, build dashboards. But agents aren't services. They reason, branch, call tools, recover from failures, and produce outputs that depend on multi-step chains of decisions. Bolting a logging pipeline onto an agent after the fact captures fragments. It doesn't capture the reasoning.

That gap between "the agent did something" and "we understand what the agent did" is where bubseek lives.

What bubseek Provides

bubseek 0.1.0 is a self-driven insight Agent — built on the bub Agent framework and OceanBase seekdb — that both serves data consumption needs and makes its own behavior fully observable. At a high level:

Why Intrinsic Observability Matters Now

Agents are joining teams — but unlike human teammates, they don't leave a paper trail that others can follow. When an agent handles a task in a group chat, its reasoning is ephemeral. When it fails silently, no one knows which step broke. When multiple agents interact across different channels, their traces scatter across disparate systems with no way to correlate them.

The conventional response is to add monitoring: deploy a separate observability stack, instrument the agent code, build custom dashboards. This works for services, but it creates a parallel system that requires its own maintenance and doesn't capture the semantic structure of agent reasoning.

bubseek takes a different approach. The agent's operation is the observability data. The bub framework's tape mechanism records the complete decision chain — not as an external logging pipeline, but as an integral part of how the agent runs. These tapes are persisted into OceanBase seekdb, where they become the subject of further analysis — by the same agent or by human operators.

This creates a closed loop: the agent serves the team, generates structured behavioral data, and that data feeds back into understanding how the team works.

How It Works in Practice

Tapes: Agent Behavior as First-Class Data

The bub framework — the engine underneath bubseek — uses a design called tapes. A tape is a complete, ordered record of one agent session: the prompt received, each reasoning step, every tool call with its arguments and return value, and the final output.

Tapes are immutable once written, but they aren't just an audit trail. In the bub framework, the tape is the agent's context — when a session resumes or hands off to another agent, the tape carries the full reasoning history forward. This dual role is what makes the design powerful: the same artifact that enables observability also serves as the working memory that the agent reasons over.

Stored in OceanBase seekdb, tapes become SQL-accessible rows with vector embeddings, enabling questions like:

Lightweight Data Consumption Without a BI Stack

Enterprise teams have fragmented data consumption needs. Marketing wants trend lines. Product wants activation metrics. Engineering wants system health. The traditional path — file a request, wait for a dashboard — is slow and expensive.

bubseek replaces that cycle with a conversational interface. Users describe their analysis need in natural language, and the agent:

The web interface runs on marimo, a reactive Python notebook. bubseek ships with pre-built dashboard templates (dashboard.py, index.py) and users can add their own notebooks in the insights/ directory. The result is a lightweight, code-as-dashboard experience — modify a parameter, re-run, iterate in seconds instead of weeks.

Scheduled Tasks and Recurring Analysis

Not all data needs are ad hoc. bubseek includes a built-in scheduler (bubseek-schedule) that supports cron expressions, interval triggers, and delayed execution. A user can say "send me the weekly engagement summary every Monday at 9 AM," and the agent creates the corresponding task. Periodic data consumption becomes a conversation, not a ticket.

GitHub Repo Cards: A Concrete Example

To illustrate data-to-insight pipelines, bubseek ships with a github-repo-cards skill. Given an org/repo identifier, it generates cards with basic repository info, star trends, and contributor data — output as SVG and PNG. It can also scrape GitHub Trending and produce a curated list. A small example, but it demonstrates the pattern: take external data, shape it into something shareable, and deliver it through the agent's channels.

The Data Layer: OceanBase seekdb

All of this data — tapes, sessions, tasks, analysis artifacts — persists in OceanBase seekdb.

seekdb is an open-source, AI-native database that combines SQL, vector similarity search, and full-text retrieval in a single engine. For bubseek, this means structured agent traces and semantic queries coexist in one system. There's no need to maintain separate databases for operational data and vector embeddings.

Configuration is a single environment variable:

export BUB_TAPESTORE_SQLALCHEMY_URL=mysql+oceanbase://user:pass@host:port/database

seekdb runs on minimal resources (1 vCPU, 2 GB RAM), supports ACID transactions, and provides real-time write and query performance. If a team's workload outgrows seekdb, the migration path to a full OceanBase distributed cluster is seamless — same SQL interface, same driver compatibility, production-grade scalability.

Why This Matters for Developers and Teams

For developers building agents: bubseek demonstrates that observability doesn't have to be a separate concern. By choosing a framework (bub) that makes traces structural rather than optional, and a database (seekdb) that handles both relational and vector data natively, you avoid the typical "agent works but we can't debug it" problem.

For teams adopting agents: The tapes stored in seekdb aren't just debugging artifacts — they're a knowledge base. Patterns in agent interactions reveal which workflows are bottlenecked, which questions recur, and where the agent's capabilities fall short. That insight feeds directly into improving both the agent and the team's processes.

For data consumers: If your BI pipeline is a bottleneck, the conversational-analysis pattern — describe what you need, get a notebook back — is worth experimenting with. bubseek shows one way to implement it without deploying a standalone analytics platform.

Getting Started

git clone https://github.com/ob-labs/bubseek.git
cd bubseek
uv sync

export BUB_TAPESTORE_SQLALCHEMY_URL=mysql+oceanbase://user:pass@host:port/database
# Configure your LLM API key — see https://github.com/ob-labs/bubseek

uv run bub chat

Or launch the web interface and visit http://127.0.0.1:2718 for notebooks and dashboards.

For full documentation and channel configuration, see the bubseek repository.

bubseek 0.1.0 is an early-stage project — the basic flow works end to end, but it's still maturing. The bub framework provides the agent core, and OceanBase seekdb provides the data layer. Contributions and feedback are welcome.