'objective05-exec: Giving Your Local Intelligence System Hands — A Rust Tutorial [post] deterministic

objective05-exec: Giving Your Local Intelligence System Hands

*How to bridge a perpetual knowledge graph to real-world tool execution — a Rust tutorial*

*June 8, 2026 · Daniel Kliewer*

[GitHub: kliewerdaniel/objective05](https://github.com/kliewerdaniel/objective05)

---

Table of Contents

• [Introduction](#introduction)
• [The Landscape: What Everyone Else Is Building](#the-landscape-what-everyone-else-is-building)
• [The Gap](#the-gap)
• [Prerequisites and Environment Setup](#prerequisites-and-environment-setup)
• [Architecture Overview](#architecture-overview)
• [Step 1: Project Structure](#step-1-project-structure)
• [Step 2: Configuration and Error Types](#step-2-configuration-and-error-types)
• [Step 3: The Tool Discovery System](#step-3-the-tool-discovery-system)
• [Step 4: The Graph Query Builder](#step-4-the-graph-query-builder)
• [Step 5: The Signal Evaluator](#step-5-the-signal-evaluator)
• [Step 6: The Tool Execution Layer](#step-6-the-tool-execution-layer)
• [Step 7: The Core Agent Runtime](#step-7-the-core-agent-runtime)
• [Step 8: The Main Entry Point](#step-8-the-main-entry-point)
• [Step 9: TOOLS.md Files](#step-9-toolsmd-files)
• [Step 10: Building and Running](#step-10-building-and-running)
• [Environment Variables Reference](#environment-variables-reference)
• [The Kuzu Schema This Agent Expects](#the-kuzu-schema-this-agent-expects)
• [Testing the Agent](#testing-the-agent)
• [Deployment Patterns](#deployment-patterns)
• [Integration with OpenClaw](#integration-with-openclaw)
• [Troubleshooting](#troubleshooting)
• [Beyond the MVP](#beyond-the-mvp)
• [Why This Matters](#why-this-matters)
• [Conclusion](#conclusion)

---

Introduction

There are two fundamental modes of intelligence: **understanding** and **acting**.

Most AI systems do one or the other. Chatbots understand — they process your input, generate a response, and forget everything when the session ends. Dashboards act — they display charts, trigger alerts, send emails — but they have no memory of what happened yesterday. The product design choices that lead here are predictable: when the model is the product, you build stateless interfaces. When the dashboard is the product, you build passive displays.

I built [Objective05](https://github.com/kliewerdaniel/objective05) to solve the understanding problem. It's a local-first intelligence system written in Rust that continuously ingests information from the web, extracts entities and claims, detects contradictions and narrative drift, maintains a temporal knowledge graph backed by Kuzu DB, and generates written reports and audio broadcasts. It listens. It thinks. It remembers.

But for months now, I've been asking a different question: **what does it do with what it knows?**

The answer matters more than you might think. Because the biggest gap in the AI landscape right now isn't between better models and worse models. It's between systems that understand deeply and systems that can actually *do* something about it.

In this post, I'm going to walk through building **objective05-exec** — the execution runtime that bridges Objective05's knowledge graph to real-world tools. By the end, you'll have a Rust-based agent that can:

• Query the Kuzu knowledge graph for context
• Evaluate whether an action is warranted based on detected patterns
• Execute real tasks: file GitHub PRs, send emails, update spreadsheets, post to Slack/Discord, write files to disk
• Discover available tools through a TOOLS.md/SKILLS.md interface (matching the OpenClaw model)
• Run on consumer hardware, fully local, fully sovereign

This is not a cloud agent. This is not a chatbot wrapper. This is a local-first agent runtime that connects deep understanding to real-world action.

---

The Landscape: What Everyone Else Is Building

Before we dive into the code, let's look at what the big players launched in the last few months. Three products define the current moment:

Microsoft Scout (built on OpenClaw)

Scout is an "always-on autonomous agent" built on the OpenClaw framework. It integrates with Microsoft 365, executes tasks across cloud and desktop, and operates with enterprise-grade security. The key feature: it doesn't wait to be asked. It monitors your calendar, drafts documents, schedules meetings, and acts across your work tools autonomously.

OpenClaw — Scout's base — is itself worth studying. It's a self-hosted, multi-channel agent gateway written in Node.js, MIT licensed, that runs on consumer hardware. It supports persistent memory across sessions, multi-agent routing, tool execution, and capability discovery via TOOLS.md/SKILLS.md files. It connects to Slack, Teams, WhatsApp, Discord, Telegram, and more. It's the scaffolding that turned "chatbots that respond" into "agents that act."

Google Gemini Spark

Spark is Google's always-on agent running on dedicated GCP VMs. It monitors Gmail, Calendar, Docs, and Sheets. Its strength: task planning and structuring, collaborative teams, repeatable workflows, and autonomous background execution. It drafts documents, makes purchases, and runs workflows without user prompting.

Anthropic Orbit

Orbit is Anthropic's proactive agent that synthesizes data from Gmail, Slack, GitHub, Calendar, Google Drive, and Figma to generate personalized daily briefings. Discovered as a hidden toggle in Claude's settings in May 2026, it represents a shift from reactive chat to proactive awareness.

---

The Gap

Look at these three products and you'll see a pattern. They're all cloud agents with tool execution. They can act — draft a doc, send an email, file a PR — but their understanding is shallow. They have no persistent knowledge graph. No temporal reasoning. No contradiction detection. No narrative tracking. They connect to your work tools, yes, but they don't *understand* them the way Objective05 understands the web.

Meanwhile, Objective05 has deep local understanding — a temporal knowledge graph that tracks entities, claims, events, and contradictions over time — but no way to act on that understanding. It can detect that a narrative is diverging in the GitHub ecosystem, but it can't file a PR to address it. It can spot a contradiction between two ArXiv papers on the same topic, but it can't draft a response. It can identify a trending pattern across Hacker News, but it can't post a summary to Slack.

**The gap is clear: Objective05 has the brain. It needs hands.**

---

Prerequisites and Environment Setup

Before writing any code, you need a working Rust toolchain and a few external services configured. The agent is designed to fail soft when credentials are missing — it will log warnings and continue with whatever tools *are* available — but a clean install goes faster with everything in place.

1. Install Rust (stable, 1.78+)

bash curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh source "$HOME/.cargo/env" rustup default stable rustc --version # should report 1.78 or newer

2. Clone the Objective05 Repository (Graph Source)

objective05-exec is a consumer of the Objective05 knowledge graph. You can either run a full Objective05 installation or stub one out:

bash # Full installation git clone https://github.com/kliewerdaniel/objective05.git cd objective05 cargo build --release ./target/release/objective05 # starts ingestion; writes to ./data/graph.db

If you only want to experiment with the execution runtime, you can use a stub Kuzu database with the schema described in [The Kuzu Schema This Agent Expects](#the-kuzu-schema-this-agent-expects).

3. Install Kuzu CLI (Optional but Useful)

The Kuzu CLI lets you inspect the graph directly:

```bash # macOS brew install kuzu

Linux curl -L https://github.com/kuzudb/kuzu/releases/latest/download/kuzu_cli-linux-x86_64.tar.gz \ | tar -xz -C /usr/local/bin ```

You can then run ad-hoc queries:

bash kuzu ../objective05/data/graph.db kuzu> MATCH (n:Narrative) RETURN n LIMIT 5;