📟Core - Introduction

What is Oobe Core? is a framework designed to facilitate the integration and management of various services and modules within a unified platform

The project aims to simplify the development of complex applications by providing modular tools and components.

The main goals of the Core include scalability, flexibility, and ease of use, enabling developers to focus on application-specific functionalities without worrying about underlying complexities.

The protocol introduces a fully modular architecture for creating intelligent agents with persistent, verifiable memory, personality, and actions. Everything is stored in a decentralized and trustless manner using:

• PDAs (Program Derived Addresses) for deterministic storage

• Memo v2 for minimal, structured, readable on-chain logs

• Merkle Trees for validating ordered data integrity

To use our SDK, you need to authenticate with an API Key. This system ensures the security of our resources and allows us to monitor service usage effectively. More info will be release soon [AUTH] [DISABLED]

Core Concepts

Agents

An agent is a composable, digital on-chain entity. It behaves like a programmable user with memory, personality, and tool-based behaviors. Agents are designed to:

• Perform tasks

• Learn from on-chain data

• Store and verify its state over time

Each agent runs tools and produces logs that are Merkle-validated for trustless replay and verification.

Tools

Tools are the building blocks of an agent’s behavior. Each Tool is a pluggable module that implements a specific logic or feature.

In our implementation, Tools are extensions of LangChain’s StructuredTool class. This structure provides built-in validation and argument parsing using Zod, ensuring that the input/output of each Tool is well-typed and robust.

A Tool must implement:

• name: Identifier of the tool

• run(): Core method to execute its logic

• schema (optional but recommended): A Zod model that defines the structured input arguments

Using StructuredTool allows each Tool to define a clear interface and integrate seamlessly with LangChain Agents.

For more information, see the LangChain documentation:

• LangChain StructuredTool Reference

Action Class Integration (LangChain-compatible)

To ensure deeper integration with LLM agents (LangChain-based), oobe-protocol introduces support for LangChain Action extensions.

These are:

• LangChain-compatible Action classes that mirror the interface of langchain_community.tools.connery.models.Action

• Designed to operate in resonance with OOBE tools

Benefits:

• Enables integration with LangChain LLM routing, reasoning, and planning workflows

• Allows seamless multi-agent collaboration between LLMs and on-chain agents

• Encapsulates action metadata, schema, and runtime in a familiar structure for Python developers

Example:

type Action = {
  name: string;
  description: string;
  inputs: z.ZodSchema<any>;
  run: (input: any) => Promise<any>;
};

Each OOBE Tool can be wrapped or exposed as an Action object for use in LangChain workflows, with schema inference handled automatically by Zod.

Resonance Mechanism:

• Tool execution logs are written on-chain via Memo v2

• Agents can compare Merkle roots and verify shared memory states across ecosystems

Architecture

Core module is built on a modular architecture that enables the integration of various components and services. This architecture is designed to be extensible and adaptable to the specific needs of each project.