# What TinyAgents Crates Does OpenHuman Depend On?

> Discover the four core TinyAgents crates OpenHuman depends on: tinyagents, tinyagents_harness, tinyagents_graph, and tinyagents_session. Understand their roles in agent harnessing, tool execution, planning, and storage.

- Repository: [Tiny Humans/openhuman](https://github.com/tinyhumansai/openhuman)
- Tags: dependency-analysis
- Published: 2026-08-31

---

**OpenHuman's Rust core depends on four primary TinyAgents crates—`tinyagents`, `tinyagents_harness`, `tinyagents_graph`, and `tinyagents_session`—to provide agent harnessing, tool execution pipelines, planning graph structures, and persistent run-ledger storage.**

OpenHuman is an open-source AI agent framework built in Rust that leverages the TinyAgents ecosystem for its core runtime capabilities. Understanding which TinyAgents crates OpenHuman depends on reveals how the system handles autonomous agent behavior, tool orchestration, and workflow persistence. This analysis examines the specific crate dependencies declared in the repository's [`Cargo.toml`](https://github.com/tinyhumansai/openhuman/blob/main/Cargo.toml) and their implementation throughout the codebase.

## Core TinyAgents Crates That OpenHuman Depends On

### `tinyagents` — The Core Agent Harness

The **`tinyagents`** crate provides the fundamental agent harness and runtime that drives each conversation turn. It exposes the `Harness` builder and high-level APIs like `run` and `turn` that coordinate agent execution. In OpenHuman, this dependency is declared in the root [`Cargo.toml`](https://github.com/tinyhumansai/openhuman/blob/main/Cargo.toml) with a vendored path:

```toml
tinyagents = { path = "vendor/tinyagents", version = "…" }

```

### `tinyagents_harness` — Tool Execution Pipeline

The **`tinyagents_harness`** crate implements the tool-execution pipeline, including policies, timeouts, and sandboxing mechanisms. It defines the `Tool` trait and `ToolExecutionContext` used throughout OpenHuman's tool system. According to the source analysis, this crate appears in [`Cargo.toml`](https://github.com/tinyhumansai/openhuman/blob/main/Cargo.toml) as:

```toml
tinyagents_harness = { path = "vendor/tinyagents_harness", version = "…" }

```

### `tinyagents_graph` — Planning and Workflow DAGs

For planning graphs and workflow management, OpenHuman depends on **`tinyagents_graph`**. This crate supplies data structures for the agent's todo/goal graph and workflow DAGs, including the "todos" sub-graph used for task management. The dependency resides at the vendored path `vendor/tinyagents_graph` and is declared in the root [`Cargo.toml`](https://github.com/tinyhumansai/openhuman/blob/main/Cargo.toml).

### `tinyagents_session` — Persistent Run-Ledger

The **`tinyagents_session`** crate handles persistent storage of agent runs, workflow executions, and telemetry data. It powers the UI's run history display and provides observability hooks for the core system. OpenHuman declares this in [`Cargo.toml`](https://github.com/tinyhumansai/openhuman/blob/main/Cargo.toml) with the path `vendor/tinyagents_session`.

## Secondary and Transitive Dependencies

### `tinyagents_tool` — Low-Level Tool Definitions

While not directly listed in [`Cargo.toml`](https://github.com/tinyhumansai/openhuman/blob/main/Cargo.toml), **`tinyagents_tool`** appears as a transitive dependency through `tinyagents_harness`. It provides low-level definitions for tool schemas, result types, and error handling that underpin the tool execution system.

### `tinyagents_graph::todos` — Task Management Facade

OpenHuman includes a compatibility façade for the legacy `tinyagents_graph::todos` module in [`src/openhuman/threads/todos/mod.rs`](https://github.com/tinyhumansai/openhuman/blob/main/src/openhuman/threads/todos/mod.rs). This module powers the "Todos" UI by re-exporting and extending the base graph functionality for task management.

## Where OpenHuman Declares TinyAgents Dependencies

The dependency declarations live in the **root [`Cargo.toml`](https://github.com/tinyhumansai/openhuman/blob/main/Cargo.toml)**, where each TinyAgents crate is vendored under the `vendor/` directory structure. The source files for these dependencies are located at:

- [`vendor/tinyagents/Cargo.toml`](https://github.com/tinyhumansai/openhuman/blob/main/vendor/tinyagents/Cargo.toml) — Core runtime source
- [`vendor/tinyagents_harness/Cargo.toml`](https://github.com/tinyhumansai/openhuman/blob/main/vendor/tinyagents_harness/Cargo.toml) — Tool execution implementation
- [`vendor/tinyagents_graph/Cargo.toml`](https://github.com/tinyhumansai/openhuman/blob/main/vendor/tinyagents_graph/Cargo.toml) — Graph algorithm implementations
- [`vendor/tinyagents_session/Cargo.toml`](https://github.com/tinyhumansai/openhuman/blob/main/vendor/tinyagents_session/Cargo.toml) — Persistent storage layer

Key integration points in the OpenHuman source include:

- [`src/openhuman/agent/tinyagents/mod.rs`](https://github.com/tinyhumansai/openhuman/blob/main/src/openhuman/agent/tinyagents/mod.rs) — Entry point that re-exports core `tinyagents` types
- [`src/openhuman/tools/traits.rs`](https://github.com/tinyhumansai/openhuman/blob/main/src/openhuman/tools/traits.rs) — Re-exports tool traits from the harness layer
- [`src/openhuman/threads/todos/mod.rs`](https://github.com/tinyhumansai/openhuman/blob/main/src/openhuman/threads/todos/mod.rs) — Compatibility layer for the todos graph module
- [`src/openhuman/web_chat/run_task.rs`](https://github.com/tinyhumansai/openhuman/blob/main/src/openhuman/web_chat/run_task.rs) — UI layer integration with harness execution and telemetry

## Code Examples: Using TinyAgents Crates in OpenHuman

### Initializing the Agent Harness

The `Harness` builder from `tinyagents` creates the runtime environment for agent execution:

```rust
use openhuman_core::openhuman::agent::tinyagents::Harness;

let harness = Harness::builder()
    .provider(openhuman_core::provider::openai_compatible("https://api.openai.com", "my‑key"))
    .workspace(openhuman_core::workspace::Ephemeral)
    .access(openhuman_core::access::full())
    .build()
    .await?;

```

### Executing Tools with Context

Tool execution utilizes `ToolExecutionContext` from `tinyagents_harness`:

```rust
use tinyagents_harness::tool::ToolExecutionContext;

let ctx = ToolExecutionContext::new(&run_config);
let result = ctx.execute_tool("search_web", json!({ "query": "rust async" })).await?;

```

### Working with Planning Graphs

The planning system uses `tinyagents_graph` types to validate workflow DAGs:

```rust
use tinyagents_graph::graph::Plan;

let plan = Plan::from_json(&json_plan)?;
plan.validate()?;               // ensures the DAG is well‑formed

```

### Persisting Run History

Run ledger operations use `tinyagents_session` to store telemetry:

```rust
use tinyagents_session::run_ledger::{upsert_agent_run, RunTelemetry};

let upsert = upsert_agent_run(
    &config.workspace_dir,
    tinyagents_session::run_ledger::AgentRunUpsert {
        run_id: run_id.clone(),
        status: tinyagents_session::run_ledger::AgentRunStatus::Running,
        ..Default::default()
    },
)?;
let telemetry = RunTelemetry { duration_ms: 123, ..Default::default() };
upsert_run_telemetry(&config.workspace_dir, telemetry)?;

```

### Managing Todo Graphs

The todos module interface works with the graph façade:

```rust
use openhuman::threads::todos::{crate_runs, CardPatch};

let runs = crate_runs(&workspace_dir)?;
let patch = CardPatch::from_diff(&old_board, &new_board);

```

## Summary

- **Four core crates**: OpenHuman depends on `tinyagents`, `tinyagents_harness`, `tinyagents_graph`, and `tinyagents_session` for its complete agent stack.
- **Vendored dependencies**: All TinyAgents crates are vendored under `vendor/` and declared in the root [`Cargo.toml`](https://github.com/tinyhumansai/openhuman/blob/main/Cargo.toml) with explicit path dependencies.
- **Tool execution**: The `tinyagents_harness` crate provides the `ToolExecutionContext` and `Tool` trait definitions used in [`src/openhuman/tools/traits.rs`](https://github.com/tinyhumansai/openhuman/blob/main/src/openhuman/tools/traits.rs).
- **Planning graphs**: `tinyagents_graph` handles DAG validation and workflow structures, with a compatibility layer in [`src/openhuman/threads/todos/mod.rs`](https://github.com/tinyhumansai/openhuman/blob/main/src/openhuman/threads/todos/mod.rs).
- **Persistence**: `tinyagents_session` manages run history and telemetry storage for UI observability.
- **Transitive dependencies**: `tinyagents_tool` is pulled in through `tinyagents_harness` for low-level tool schemas and error types.

## Frequently Asked Questions

### What is the primary TinyAgents crate for agent runtime in OpenHuman?

The **`tinyagents`** crate provides the core agent harness and runtime, exposing the `Harness` builder and high-level `run`/`turn` APIs that coordinate agent execution cycles. It is declared in the root [`Cargo.toml`](https://github.com/tinyhumansai/openhuman/blob/main/Cargo.toml) with the path `vendor/tinyagents`.

### How does OpenHuman persist agent run history?

OpenHuman uses the **`tinyagents_session`** crate to maintain a run-ledger that stores every agent run, workflow execution, and telemetry data. This enables the UI layer to display historical run information and supports system observability through functions like `upsert_agent_run()` and `upsert_run_telemetry()`.

### Where are the TinyAgents dependencies declared in the OpenHuman repository?

All TinyAgents crate dependencies are declared in the **root [`Cargo.toml`](https://github.com/tinyhumansai/openhuman/blob/main/Cargo.toml)** using vendored paths (e.g., `path = "vendor/tinyagents"`), with corresponding source code located in [`vendor/tinyagents/Cargo.toml`](https://github.com/tinyhumansai/openhuman/blob/main/vendor/tinyagents/Cargo.toml), [`vendor/tinyagents_harness/Cargo.toml`](https://github.com/tinyhumansai/openhuman/blob/main/vendor/tinyagents_harness/Cargo.toml), [`vendor/tinyagents_graph/Cargo.toml`](https://github.com/tinyhumansai/openhuman/blob/main/vendor/tinyagents_graph/Cargo.toml), and [`vendor/tinyagents_session/Cargo.toml`](https://github.com/tinyhumansai/openhuman/blob/main/vendor/tinyagents_session/Cargo.toml).

### Does OpenHuman use any TinyAgents crates transitively?

Yes, OpenHuman transitively depends on **`tinyagents_tool`** through `tinyagents_harness`, which provides low-level tool schema definitions and error types. While not directly listed in [`Cargo.toml`](https://github.com/tinyhumansai/openhuman/blob/main/Cargo.toml), it appears in the compiled dependency graph and is used for tool result handling and validation.