Mike Hostetler mikehostetler

Jido Issue Bot V2 — Runic Spine + ReAct Brain

Philosophy

V1 had two extremes: the fully-structured Runic DAG (deterministic but brittle) and the pure ReAct agent (adaptive but unreliable on lifecycle). V2 takes the best of both:

Runic owns the lifecycle. ReAct owns the investigation.

The outer Runic workflow guarantees that Sprites get created, repos get cloned, results get pushed to GitHub, and Sprites get destroyed — deterministically, with per-step observability and retry semantics. The inner ReAct agent gets delegated the creative, adaptive work: directing Claude Code to actually fix the bug, iterating on test failures, and composing the investigation report.

Jido Issue Triage Bot — Pure ReAct Approach

Philosophy

No Runic DAG. No structured pipeline. No orchestrator. Just a Jido.AI.Agent with tools and a good prompt. The LLM decides what to do, in what order, and how to recover from errors — exactly like a human developer would.

mix jido.triage https://github.com/agentjido/jido/issues/42

┌──────────────────────────────────────────────────────┐

Jido Sessions: Mapping AgentSessionManager onto Jido

Integration analysis of nshkrdotcom/agent_session_manager (ASM) onto Jido's existing architecture.

Executive Summary

ASM provides session lifecycle management, event logging, transcript reconstruction, provider adapters (Claude/Codex/Amp), policy enforcement, routing/circuit-breaking, and concurrency limiting for LLM agent interactions.

Jido already has equivalents for ~80% of this. The remaining ~20% (provider-specific LLM execution, workspace instrumentation, and a convenience session API) can be added as plugins, custom directives, and thin glue modules — no new runtime or parallel process hierarchy needed.

RLM — BEAM-Native Implementation Plan for Jido.AI

Implements the Recursive Language Model pattern using native Jido/BEAM semantics. No regex parsing. No Python subprocess. No exec().

Supersedes RLM_STRATEGY.md. See RLM_STRATEGY_CRITIQUE.md for rationale.

Core Insight

Proposal: Default Plugins as the Universal Composition Mechanism

Summary

This proposal argues that Jido.Identity — and eventually other "reserved key" primitives like __thread__, __memory__, and __strategy__ — should be implemented as default plugins rather than ad hoc reserved keys with standalone helper modules. The goal is to keep the agent core minimal (four functions: new/1, set/2, validate/2, cmd/2) while proving that the plugin system is robust enough to serve as the universal composition layer for both framework primitives and user extensions.

The Problem: Reserved Key Sprawl

Jido Identity Design

Overview

Identity is a first-class agent primitive — a mostly-stable self-model stored under the reserved key __identity__ in agent.state. It answers two questions:

What can this agent do? — Capabilities for orchestration and routing
What lifecycle facts matter? — Age, creation context, evolution state

Identity is intentionally not world knowledge (__memory__), not event history (__thread__), and not decision logic (__strategy__). It's the agent's machine-readable resume.

GitHub Issue Bot Workflow Analysis

Problem Statement

Goal: Respond to a GitHub Issue submission by researching the problem and posting a Pull Request with a solution.

Standard Operating Procedure (SOP)

Jido AI ReAct Thread Integration: LLM Context as Projection

Executive Summary

This document specifies the integration of Jido.Thread with the ReAct strategy, implementing the key insight from JIDO_THREAD.md: Thread is the canonical history; LLM context is a derived projection.

The Machine's conversation list becomes ephemeral—generated fresh each LLM call from Thread via a ContextPolicy projector. This enables token budgeting, windowing, summarization, and provider-agnostic storage while keeping the full interaction history intact.

OpenClaw Architecture Overview

OpenClaw is a multi-channel message routing layer wrapped around an embedded "coding agent" runtime (pi-agent-core). It enables AI agents to operate across messaging platforms (Telegram, Discord, Slack, Signal, iMessage, WhatsApp, etc.) with unified tool access, session management, and extensibility.

High-Level Architecture

┌─────────────────────────────────────────────────────────────────┐

	#!/usr/bin/env elixir

	Mix.install([
	{:req_llm, path: ".."}
	])

	Logger.configure(level: :warning)

	defmodule SimpleAgent.V1 do
	use GenServer