# Core - Introduction
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
{% hint style="info" %}
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\]*](https://oobe-protocol.gitbook.io/oobe-protocol/getting-started/broken-reference) *\[DISABLED]*
{% endhint %}
### 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](https://python.langchain.com/docs/modules/agents/tools/custom_tools/#structured-tools)
#### 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`](https://python.langchain.com/api_reference/community/tools/langchain_community.tools.connery.models.Action.html)
* 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:**
```typescript
type Action = {
name: string;
description: string;
inputs: z.ZodSchema;
run: (input: any) => Promise;
};
```
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.\
\
---
# Agent Instructions: Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.
Perform an HTTP GET request on the current page URL with the `ask` query parameter:
```
GET https://oobe-protocol.gitbook.io/oobe-protocol/getting-started/quickstart.md?ask=
```
The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.
Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.