Story Architecture Live Pulse Blog Contact
lobs-core · Standalone Agent Runtime

Building the most
advanced personal
AI agent system.

|

0 versions shipped
0 specialized agents
0 active workflows
24/7 autonomous operation
Read the Story See the Architecture →

The Origin

One dev.
An entire team of agents.

What started as a structured task framework became a fully standalone agent runtime. Eight versions, each driven by a hard production ceiling.

Built by Rafe because it is genuinely useful and interesting to build. The goal was never just an AI assistant. It was a workforce: specialized agents that run autonomously, pick up tasks, and deliver results around the clock.

Eight versions. Each one forced by a hard ceiling hit in production. Every limitation became the next version's motivation.

v1

Custom Task Framework, Jan 2026

Single agent inside OpenClaw — a powerful AI coding tool — with a custom task framework for managing work. OpenClaw was the launchpad: a capable, well-designed platform that made it possible to start building immediately. Gave structure to AI work beyond raw chat prompts.

Why it wasn't enough

One agent could not handle complex multi-step work. There was no parallelism. The ceiling appeared fast. As soon as more than one thing needed to happen at once, progress stalled.

v2

Multi-Agent System, Early Feb 2026

Multiple specialized agents: Programmer, Writer, Researcher, Reviewer, Architect. Agent spawning and task routing made parallel work possible.

Why it broke down

There was no memory between sessions. Agents repeated the same mistakes. Every session started cold, and lessons disappeared as soon as the session ended.

v3

Reflections & Learning, Mid Feb 2026

An agent reflection system captured completed work. Shared memory persisted lessons across sessions. Agents improved over time instead of starting over.

Why it wasn't enough

Still running as scripts and manual orchestration. No proper server or API. Couldn't scale coordination or run reliably in the background without babysitting.

v4

Web Server Era, Late Feb 2026

lobs-server: FastAPI backend with REST API, task queue, worker management, health monitoring. Mission Control (SwiftUI macOS) and Lobs Mobile (iOS) joined the ecosystem.

Why it broke down

38K lines of Python. Task execution relied on linear if/else chains with no branching, rollback, or complex workflows. The codebase became genuinely hard to maintain.

v5

DAG Workflow Engine, Late Feb 2026

Node-based DAG workflow system. State machines, conditional branching, rollback, event-driven triggers, cron scheduling. 20 workflow definitions shipped.

Why it needed replacing

The Python codebase was massive and fragile. Running a separate server process added architectural complexity — that was a consequence of the design, not a flaw in OpenClaw. The glue layer was heavier than the logic it connected.

v6

OpenClaw Plugin, Mar 2026

Full rewrite as an OpenClaw TypeScript plugin. Ran inside OpenClaw — a great host — with no separate server process. Everything from v1–v5 preserved but dramatically cleaner. The plugin phase was the right consolidation step.

The breakthrough

The glue layer disappeared. The system became a single process. Circuit breaker, five-tier model chooser, and budget guard were first-class parts of the runtime. That rewrite replaced a much larger Python stack with a leaner TypeScript core.

38,000 lines Python → leaner TS core one process
v7

Nexus Dashboard & Custom Domain, Mar 2026

Nexus: React + Vite web dashboard replacing the SwiftUI macOS app. Self-hosted at lobslab.com with Caddy auto-TLS + Cloudflare Tunnel. The system got a real home on the web.

The breakthrough

Cross-platform access from any device. Public site at lobslab.com, private Nexus dashboard over Tailscale. Workers autonomously fix UI bugs. The system builds its own interface.

v8

Standalone Runtime (lobs-core), Mar 2026 [CURRENT]

Lobs graduates to its own standalone runtime. lobs-core now runs as its own Node.js process with a custom LLM execution loop, built-in HTTP server, Discord bot, memory supervision, and an integrated dashboard. The custom runtime exists because building agent systems is the career path I'm on — first-semester CSE MS at the University of Michigan, GSI for EECS 281 and 291, and building this to deeply understand every layer. OpenClaw was the launchpad that made it all possible.

The breakthrough

No external platform dependency remains in the runtime path. lobs-core calls provider APIs directly, manages its own workers, serves Nexus from its own HTTP server, runs lobs-memory under supervision, and starts from a native CLI. One lobs start command boots the system.

born in OpenClaw → fully custom runtime no host dependency

By the Numbers

The Stats

Real numbers from a system that actually runs in production, every day.

0
versions shipped
v1 task framework → v8 standalone runtime. Eight hard ceilings hit and broken through in under three months.
0
agent types
Lobs, Programmer, Writer, Researcher, Reviewer, and Architect. Each has its own model tier and tool configuration.
0
active workflow definitions
Multi-step DAGs covering code, research, review, and reporting flows. State machines with branching and rollback.
0
model tiers
From free local Qwen to Claude Opus, auto-selected by task complexity. The cheapest model that can handle the task wins.
0
lines of platform TypeScript
Total lines across owned source directories in lobs-core (67k), lobs-nexus (19k), lobs-mobile (5.6k), lobs-memory (3k), lobs-vim (2.1k), lobs-sentinel (1.2k), and supporting services.
24/7
autonomous operation
Workers spawn, execute, and complete without supervision. Zero manual intervention after task creation.

Live System

Live Pulse

Real telemetry from the production system. Updated daily. No synthetic data. This is real.

Fetching telemetry…

System Design

How It All Fits Together

A layered architecture where Lobs is the chat interface and coordinator, lobs-core orchestrates work, and specialized workers execute in parallel. Automatic model selection and fault tolerance are built in.

RF
Rafe
Human
The human. Sends messages, creates tasks, reviews results via Discord, iOS, or direct DB.
LB
Lobs
Chat & Coordinator
Primary agent. Runs 24/7. Triages requests, creates tasks, routes to the lobs-core orchestrator. The face of the system.
LOBS-CORE ORCHESTRATOR, STANDALONE RUNTIME
WF
Workflow Engine
20 workflow definitions. DAG execution, branching, rollback, cron triggers.
20 workflow definitions. DAG execution with state, branching, and rollback. Event-driven triggers and cron scheduling.
MC
Model Chooser
5 tiers from local Qwen to Claude Opus. Cost-aware, fallback chains.
Tier-based model selection. Auto-fallback chains on failure. Cheapest model that handles the task wins.
CB
Circuit Breaker
Failure detection, worker quarantine, escalation, and recovery.
Tracks worker failure rates. Quarantines bad actors. Prevents cascading failures.
DB
Task DB
SQLite task queue with full history, status, and agent assignment.
SQLite-backed task queue. Full task history, worker run records, workflow state.
PG
Programmer
Code & tests
Writes code, fixes bugs, runs tests, refactors. Default: standard tier.
WR
Writer
Docs & content
Creates docs, write-ups, summaries, content. Default: small tier.
RS
Researcher
Analysis & synthesis
Researches topics, compares options, synthesizes findings. Default: medium tier.
RV
Reviewer
QA & feedback
Code review, quality checks, feedback. Runs after Programmer.
AR
Architect
Design & strategy
Technical strategy, design docs, planning. Default: strong tier (Opus).

Model Tier Selection, auto-matched by task complexity

microQwen local · free
→
smallSonnet
→
mediumSonnet+
→
standardCodex/Sonnet
→
strongClaude Opus

Falls back up the chain on failure. Cheapest model that can handle the task always wins.

End-to-End Flow

How It Actually Works

From a message to a completed deliverable: six steps, zero manual intervention after the first.

01

Rafe sends a message or creates a task

Via Discord DM, the iOS app, or directly in the task database. Natural language and structured input both work.

02

Lobs triages and routes

Reads the request, determines urgency and agent type, breaks it into subtasks if needed, and writes it to the task queue with the right model tier.

03

lobs-core orchestrator matches to a workflow

The control loop picks up active tasks, matches them to workflow definitions if applicable, and sequences the work across multiple agent types.

04

Model chooser selects the right tier

Based on task complexity, agent type, and cost budget. If a model fails, the circuit breaker triggers an automatic fallback up the tier chain.

05

Worker agent spawns and executes

A sandboxed agent session fires up with the appropriate agent config, workspace, and tool access. Max 2 concurrent workers. 15-minute timeout enforced.

06

Results captured, task completed, learning stored

Worker output lands in the task DB. Lessons learned feed into shared memory. Rafe gets a quiet notification only when it matters.

bash, create a task directly 
# Insert a task into the lobs-core DB. The orchestrator picks it up within 10s
sqlite3 ~/.lobs/lobs.db \
  "INSERT INTO tasks
     (id, title, status, agent, model_tier, notes, created_at, updated_at)
   VALUES (
     lower(hex(randomblob(16))),
     'Refactor auth module to use JWT',
     'active', 'programmer', 'standard',
     'Follow existing patterns in /src/auth. Add tests.',
     datetime('now'), datetime('now')
   );"

# Worker spawns, codes, commits, reports back. Zero babysitting.

Sub-Projects

The Building Blocks

Interlocking projects that make up the Lobs AI ecosystem. Current owned-code footprint by cloc: lobs-core 67k, lobs-nexus 19k, lobs-mobile 5.6k, lobs-memory 3k, lobs-vim 2.1k, lobs-sentinel 1.2k, lobs-voice 0.5k, website 4.5k.

LC
lobs-core

lobs-core

+

The standalone agent runtime. TypeScript monorepo that runs as its own Node.js process. Orchestrator, agent runner, context engine, workflow system, HTTP server, Discord bot, voice pipeline, and live meeting transcription — all in one. Current owned source footprint: about 67k lines of code by cloc.

TypeScriptSQLiteNode.js67k LOCCurrent
WF
Workflow Engine

DAG execution with state machines, conditional branching, rollback, event-driven triggers, and cron scheduling.

MC
Model Chooser

Five-tier cost-aware model selection with per-agent fallback chains. The cheapest model that can handle the task wins.

CB
Circuit Breaker

Tracks worker failure rates, quarantines bad actors, and prevents cascading failures.

DB
Task Database

SQLite via drizzle-orm. Full task history, worker run records, workflow state, and research memos.

CLI
Native CLI

lobs init, lobs start, lobs status, and lobs logs manage the system without a host platform.

API
Direct Provider Calls

The runtime calls Anthropic, OpenRouter, LM Studio, and other OpenAI-compatible endpoints directly through its own runner.

MEM
Memory Supervision

lobs-memory runs under lobs-core supervision, so semantic search is part of the runtime instead of an external bolt-on.

QA
Post-Success Validation

Artifact validation and selective review triggers catch phantom completions before bad output gets marked done.

DT
Dynamic Tools

Agents can create, edit, and delete their own tools at runtime — shell scripts, TypeScript modules, or procedural steps that persist across sessions.

SL
Self-Learning Loop

Corrections and preferences are captured in persistent memory automatically, so the same mistake never happens twice.

NX
lobs-nexus

Nexus Dashboard

+

React + Vite web dashboard served directly by lobs-core. Real-time monitoring of agents, tasks, workflow runs, and system health. Includes agent chat, live meeting transcription with AI activity feed, and brain dump task capture. Current owned frontend footprint: about 19k lines of code by cloc.

ReactViteTailwind19k LOCCurrent
AS
Agent Status Monitoring

View all six agent types in idle, running, or error state, with worker history and success rates.

WV
Workflow Visualization

Active workflow steps, completed nodes, and pending branches are visible in the dashboard.

PU
Polling-Based Updates

Periodic polling tracks task state changes, worker completions, and system alerts. WebSocket support is planned.

TI
Task Inspector

Inspect notes, agent assignment, model tier, worker run log, output, and timing in one view.

MT
Live Meeting Transcription

Record meetings from the browser with real-time transcription and an AI activity feed that extracts action items, decisions, flags, and open questions as the meeting happens.

VI
lobs-vim

Neovim Plugin

+

AI coding agent for Neovim. Reasoning runs on lobs-core, tools execute locally in your editor. File editing, shell commands, search — all with an approval system for dangerous operations. About 2.1k lines across Lua and TypeScript.

LuaTypeScriptNeovim2.1k LOCCurrent
LT
Local Tool Execution

The LLM reasons on the server; file edits, shell commands, and searches run locally in Neovim. No round-trip for tool execution.

AP
Exec Approval System

Dangerous commands require explicit approval. Safe operations (reads, searches) run automatically. Configurable trust levels.

CTX
Project Context Injection

Automatically sends project context on new sessions so the agent understands the codebase from the first message.

WS
WebSocket Streaming

Real-time streaming of agent responses and tool calls over WebSocket. Cookie-based auth ties into lobs-core's session system.

ST
lobs-sentinel

Sentinel Agents

+

Persistent single-purpose AI agents for GitHub. Each sentinel runs in Docker, watches repos, and performs one job: reviewing PRs, triaging issues, or auto-labeling. Multi-provider LLM support (Anthropic + OpenAI). About 1.2k lines of TypeScript.

TypeScriptDockerGitHub API1.2k LOCCurrent
RV
PR Reviewer

Reviews pull requests with full context — diffs, comments, commit history. Posts code review comments and approve/request-changes decisions.

LB
Auto-Labeler

Classifies issues and PRs by content and applies labels automatically. Keeps repos organized without manual triage.

TR
Issue Triage

Categorizes new issues, assigns priority, and asks clarifying questions. First-responder for incoming work.

MP
Multi-Provider LLM

Supports Anthropic and OpenAI models. Per-deployment config lets you pick the right model for the task and budget.

VC
lobs-voice

Voice Pipeline

+

Local STT + TTS sidecar services for Discord voice integration. Whisper.cpp handles speech-to-text, Chatterbox handles text-to-speech. The voice module in lobs-core bridges Discord voice channels to the agent pipeline. About 500 lines of Python and shell scripts.

PythonWhisper.cppChatterbox TTS0.5k LOCCurrent
STT
Speech-to-Text

Whisper.cpp with CoreML acceleration on Apple Silicon. Converts Discord voice input to text for agent processing.

TTS
Text-to-Speech

Chatterbox TTS server generates natural speech from agent responses. Streams audio back into Discord voice channels.

BR
Voice Bridge

The voice module in lobs-core connects Discord voice channels to the STT → Claude → TTS pipeline. Fully local, no cloud speech APIs.

RT
OpenAI Realtime

Alternative speech-to-speech bridge using OpenAI's Realtime API for lower-latency conversational voice interaction.

iOS
lobs-mobile

Lobs Mobile

+

iOS companion app for staying connected to your agents on the go. Check task status, receive completions, and interact with Lobs from your phone.

SwiftiOSPush notifications5.6k LOCCurrent
PN
iOS Push Notifications

Get notified when blockers arise, urgent tasks complete, or the system needs attention without checking Discord.

TC
Task Creation On The Go

Create tasks from anywhere. The orchestrator picks them up within ten seconds.

QV
Task Queue View

Browse active, completed, and blocked tasks. Filter by agent type or model tier, and see what is running now.

CI
Chat Interface

Message Lobs directly from the app. Same coordinator, same routing, just on mobile instead of Discord.

ME
lobs-memory

Memory Search

+

Hybrid search server for agent memory. Combines BM25 keyword search with vector embeddings for semantic retrieval across all agent context, learnings, and project documentation. Runs on port 7420 under lobs-core supervision. About 3k lines of TypeScript and Python.

TypeScriptPythonEmbeddings3k LOCCurrent
HB
Hybrid Search

BM25 keyword matching combined with dense vector search. Best of both worlds for finding relevant context across hundreds of memory files.

EM
Embeddings

Local embedding generation for all indexed content. No external API calls needed for search — everything runs on the same machine.

SV
Supervised Process

Runs under lobs-core process supervision with automatic restart on failure. Health checks ensure search is always available to agents.

IX
Multi-Collection Index

Indexes workspace files, shared memory, daily logs, project docs, and ADRs as separate searchable collections.

KB
lobs-shared-memory

Shared Memory

+

A Git-backed cross-project knowledge base. ADRs, research memos, runbooks, and agent instructions that persist across sessions and sync across the entire system. The supporting lobs-memory search service provides hybrid BM25 + vector search over the knowledge base.

GitMarkdownADRsRunbooks
ADR
Architecture Decision Records

Every major technical decision is recorded as an ADR: what was decided, why, and what alternatives were rejected. Agents read these before acting.

GS
Git-Backed Sync

All memory files live in a git repo. Changes are committed and synced. Workers can read, agents can write, and everything is auditable.

RM
Research Memos

Researcher agents write structured memos that persist across sessions. When a similar question returns, the answer is already there.

RB
Agent Runbooks

Operational playbooks for each agent type explain edge cases, preferred tools, and failure modes. They keep evolving with the system.

LL
lobslab-apps

LobsLab Apps

+

Web apps hosted on lobslab.com subdomains. Crapuler (UMich course watchlist), Ballz (physics toy), Stellar Siege (cosmic RTS), and more. Each app runs in Docker with Caddy reverse proxy. About 16k lines of code plus course catalog data.

JavaScriptDockerCaddy16k LOCCurrent
CR
Crapuler

UMich course section watchlist. Monitors registration status and alerts when seats open. Backed by 50k lines of course catalog JSON data.

BZ
Ballz

Physics sandbox with 10k lines of vanilla JavaScript. Bouncing balls with collision, gravity, and interactive controls.

SS
Stellar Siege

Cosmic real-time strategy game. Conquer star systems, build fleets, and manage resources across a procedurally generated galaxy.

DK
Docker + Caddy Stack

Each app containerized independently. Caddy handles automatic TLS and subdomain routing. Add a new app with a Dockerfile and one compose entry.

UM
Course

EECS 498-016

+

Applied Agentic Software Engineering — hands-on course building autonomous AI agents that do real work. Covers agent architectures, tool use, memory systems, multi-agent orchestration, and deployment. Uses OpenClaw as the runtime. Co-developed with Marcus Darden at the University of Michigan.

University of MichiganEECSOpenClaweecs498-aase.github.io ↗
AG
Agent Architectures

Designing and implementing autonomous agents: reasoning loops, tool use, and goal-directed behavior.

TU
Tool Use & Memory Systems

Building agents that use tools effectively and maintain persistent memory across sessions.

MA
Multi-Agent Orchestration

Coordinating multiple agents to work in parallel on complex, multi-step tasks.

DP
Deployment & Runtime

Taking agents from prototype to production using OpenClaw as the runtime platform.

API
lobs-server, Legacy / Retired

lobs-server

+

The FastAPI backend that powered v4 and v5: REST API, task queue, worker management, and health monitoring. Replaced by lobs-core. 38K lines of Python that taught us everything.

PythonFastAPISQLiteRetired
API
REST API

Full task management API to create, read, update, and delete tasks and projects. It backed Mission Control and Lobs Mobile before the standalone era.

PY
Python Orchestrator

Multi-agent spawning with aiohttp. It taught us the cost of race conditions, session leaks, and if/else workflow logic at scale.

HM
Health Monitoring

Worker status tracking, failure rates, and uptime metrics. Those patterns directly influenced lobs-core's circuit breaker design.

RT
Why It Was Retired

The Python stack grew large and hard to maintain. The glue was heavier than the logic it connected. lobs-core replaced it completely.

Changelog

Build Timeline

Eight versions. Three months. A system that actually runs in production, every day.

Jan 2026

v1, Custom Task Framework

Lobs comes online. A custom task framework gives structure to AI work beyond raw chat prompts. Single agent, single session, but a real foundation.

v1 · task framework
Early Feb

v2, Multi-Agent System

Multiple specialized agents: Programmer, Writer, Researcher, Reviewer, Architect. Agent spawning and task routing. Parallel work becomes possible for the first time.

v2 · multi-agent
Mid Feb

v3, Reflections & Learning

Workers reflect on completed tasks. Lessons get written to shared memory. The system starts getting smarter over time, not just faster, without manual updates.

v3 · learning
Late Feb

v4, Web Server Era

lobs-server FastAPI backend deployed. Mission Control (SwiftUI macOS) and Lobs Mobile (iOS) join the ecosystem. Real infrastructure: APIs, monitoring, and mobile access.

v4 · server + apps
Late Feb

v5, DAG Workflow Engine

Multi-step tasks now run as structured workflows with state, branching, and rollback. 20 workflow definitions covering code, research, review, reporting. Complex work becomes a pipeline, not a prompt.

v5 · DAG workflows
Mar 2026

v6, OpenClaw Plugin Rewrite (TypeScript)

The big one. Full rewrite as an OpenClaw TypeScript plugin — and a great move. Running inside OpenClaw as a first-class plugin eliminated the separate server entirely. Everything from v1-v5 stayed intact, but cleaner. The glue layer disappeared, and the system became dramatically smaller than the Python stack it replaced.

v6 · OpenClaw plugin
Mar 2026

v7, Nexus Dashboard & Custom Domain

React + Vite web dashboard replaces SwiftUI macOS app. Self-hosted at lobslab.com with Caddy auto-TLS and Cloudflare Tunnel. Private Nexus dashboard over Tailscale. Workers autonomously implement UI fixes.

v7 · Nexus dashboard
Mar 2026

v8, Standalone Runtime (lobs-core)

Lobs graduates to its own custom runtime. lobs-core runs as its own Node.js process with custom LLM execution, built-in HTTP server, Discord bot, integrated Nexus dashboard, and supervised memory server. Built from scratch to deeply understand every layer — from LLM calls to tool orchestration to memory management — and to be ready to teach it. One lobs start boots the whole system.

v8 · standalone runtime
Mar 13

Standalone Milestone, Self-Contained v2

The architecture shifted from plugin dependency to self-contained runtime. Direct provider calls, a native Discord service, browser-based web tools, and a slimmer orchestrator became the plan of record.

standalone milestone · ADR-010
Mid Mar

Standalone Milestone, Native CLI and Process Control

lobs init, lobs start, lobs stop, lobs status, and lobs logs gave the system its own operational surface. No host app needed to boot, inspect, or manage the runtime.

standalone milestone · native ops
Mid Mar

Standalone Milestone, Runtime Owns the Stack

lobs-core now starts its own HTTP server, serves Nexus directly, supervises lobs-memory, runs its own Discord bot, and validates worker output after completion. The runtime is fully custom — a deliberate choice to understand every layer, not a rejection of OpenClaw.

standalone milestone · fully custom
Late Mar

Voice Pipeline & Live Meeting Transcription

Lobs joins Discord voice channels. Local Whisper.cpp for STT, Chatterbox for TTS, with the voice module in lobs-core bridging it all to the agent pipeline. Live meeting transcription with speaker detection followed — real-time notes from any voice call.

voice · meetings · STT/TTS
Early Apr

Dynamic Tools, Self-Learning & Memory Refactor

Agents can now create their own tools at runtime — shell scripts, TypeScript, or procedural steps that persist across sessions. A self-learning loop captures corrections into permanent memory. The memory system got a major refactor: SessionWatcher removed, compaction-triggered reflection, and 75 pre-existing test failures fixed in one push.

dynamic tools · self-learning · you are here

Field Notes

Wins & Hard-Won Lessons

Real systems break in real ways. Every incident below happened in production. None were fun. All were instructive.

WM Wins & Milestones

MP

Multi-Agent Parallelism

Multiple specialized agents work on different tasks at the same time. Programmer codes, Researcher investigates, Writer documents. The ceiling on what one person can accomplish expanded dramatically.

RL

Agent Reflection & Learning

Workers reflect on completed tasks, capture lessons, and feed back into shared memory. The system gets meaningfully better week-over-week without manual updates. Mistakes stop repeating.

WF

Workflow Engine as Control Plane

Multi-step tasks now run as structured DAG workflows with state, branching, and rollback, not one-shot prompts. That made work possible that previously required constant babysitting.

MT

Model Tier System

Tasks automatically route to the cheapest model that can handle them. First week of operation: 60% of tasks handled by the free local model. Cost stays manageable at scale.

SR

Standalone Runtime Win

Going standalone removed an entire class of problems: platform dependency, IPC overhead, session handshake failures, sync issues, and deployment complexity. One process. No glue.

FC

Fully Custom Runtime

The current system owns its process model, CLI, HTTP server, Discord integration, provider calls, memory supervision, and worker lifecycle. What started inside OpenClaw is now a ground-up custom runtime — built to teach, built to learn, built to last.

LS Losses & War Stories

RL

The Restart Loop Incident HIGH

Workers edited plugin source code, then called gateway restart. The restart spawned fresh workers. Who picked up active tasks. Who edited source and called restart. Infinite loop. The system was restarting itself every 30 seconds for 20 minutes before it was caught.

What we learned

Gateway restart is now hard-denied in all worker agent tool configs. Workers can read source but cannot modify it. Defense in depth over clever permission systems.

HS

Heartbeat Spam MEDIUM

Background exec commands in workers triggered event-driven heartbeats on completion, flooding the main session with "Exec completed" noise. At peak, 40+ heartbeat messages arrived in 10 minutes. Actual notifications disappeared in the noise.

What we learned

Banned all background exec patterns (&, nohup, sleep &&) in worker configs. Direct, synchronous commands only. The AGENTS.md now has a whole section on this.

JB

JSON Double-Conversion Bug MEDIUM

Swift's .convertFromSnakeCase was set on the decoder. Then manual CodingKeys were added for the same mapping. The decoder applied both. Fields silently dropped. No errors, just missing data. It took two sessions to diagnose.

What we learned

Never add CodingKeys for simple snake→camel conversions when .convertFromSnakeCase is active. Now documented as permanent institutional knowledge in TOOLS.md.

OS

Session Validation Errors LOW

"No tool call found" errors came from workers that completed their task without making any tool calls. Session validation expected at least one tool call, so workers answering purely from context failed and got retried, wasting tokens.

What we learned

Stricter session validation distinguishing "no tools needed" from "something went wrong." Simple tasks that don't need tools are now explicitly tagged at creation time.

RS

Reflection Spam LOW

Agent reflection was too eager. Workers reflected after every minor action: reading a file, running a test, making a small edit. Shared memory grew by hundreds of low-quality entries in a single day. Signal got buried in noise.

What we learned

Reflection now gates behind strict completion criteria and rate limits. Only significant task completions trigger reflection. Quality over volume, every time.

Technologies

The Tech Stack

No magic. Just well-chosen tools assembled with intention. Every component earns its place.

ND
Node.js
Standalone runtime
TS
TypeScript
lobs-core & orchestrator
SQL
SQLite
Task & workflow database
RX
React + Vite
Nexus dashboard
PY
Python
Legacy lobs-server (retired)
CI
GitHub Actions
CI/CD & automation
CL
Claude
Anthropic · strong/standard
GPT
Codex / GPT
OpenAI · standard tier
QW
Qwen (local)
LM Studio · micro tier · free
DC
Discord
Primary chat interface
CF
Cloudflare
DNS + Tunnel
GT
Git
Shared memory sync

Get In Touch

Contact

Interested in lobs-core, have questions about the architecture, or want to collaborate? Reach out.

GH
GitHub
github.com/lobs-ai
IN
LinkedIn
linkedin.com/in/rafe-symonds
UM
Built by
Rafe Symonds, University of Michigan CSE