An Open-Source Harness for Long-Running Autonomous Agentic Development in Production

See a demo of an open-source harness enabling reliable, multi-session autonomous agentic development, building a full DAW in 20 hours.

LLM SQLite FTS5 Semantic embeddings Go Rust Agentic coding CLI tool frontier models (Claude Gemini GPT compound-agent (npm) Beads GitHub

Overview

I built an open-source agentic coding CLI plugin that packages three requirements for reliable autonomous coding into one system: persistent semantic memory, mechanical feedback loops, and navigable task structure. It runs multi-session agentic work in dependency order, each task through a full cycle of specification, planning, test-driven implementation, multi-model review, and lesson extraction, with no shared context between sessions.

I’ll demo it through its benchmark: a fully functional browser-based DAW (subtractive synth, drum machine, piano roll, mixer, effects chain) built in 20 hours of unattended autonomous work. This is the same challenge Anthropic ran internally with their unpublished harness (https://www.anthropic.com/engineering/harness-design-long-running-apps, March 24 2026).

The harness is open-source, and I’m deploying features and apps in production at my tech company.

Links

https://nathan-delacretaz.com/thinks/compound-agent-harness
`compound-agent` orchestrates autonomous coding via git-backed tasks and RAG-based memory.
https://nathan-delacretaz.com/thinks/harness-design
Open-source multi-agent harness orchestrating autonomous, long-running software engineering sessions.
https://www.anthropic.com/engineering/harness-design-long-running-apps
Anthropic's multi-agent harness enables autonomous full-stack development via GAN-inspired loops.
https://openai.com/index/harness-engineering/
https://www.anthropic.com/engineering/building-c-compiler
Parallel Claude Opus 4.6 agents autonomously built a Rust-based, GCC-compatible C compiler.
https://cursor.com/blog/self-driving-codebases
Autonomous multi-agent system achieves high-throughput software engineering via decentralized execution.
https://github.com/steveyegge/beads)

Tech stack

LLM

Large Language Models (LLMs) are deep learning models, built on the Transformer architecture, that process and generate human-quality text and code at scale.

LLMs are a class of foundation models: massive, pre-trained neural networks (often with billions to trillions of parameters) that leverage the self-attention mechanism of the Transformer architecture (introduced in 2017) to predict the next token in a sequence. Trained on vast datasets (e.g., Common Crawl's 50 billion+ web pages), these models—like GPT-4, Gemini, and Claude—acquire predictive power over syntax and semantics. They function as general-purpose sequence models, enabling critical applications such as complex content generation, language translation, and automated code completion (e.g., GitHub Copilot). Their core value: generalizing across diverse tasks with minimal task-specific fine-tuning.

https://en.wikipedia.org/wiki/Large_language_model

View projects
SQLite FTS5

A high-performance full-text search engine built directly into SQLite for lightning-fast indexing and prefix matching.

FTS5 transforms SQLite into a robust search engine by implementing a virtual table module that handles complex text queries across massive datasets. It supports advanced features like the BM25 ranking algorithm for relevance scoring, custom tokenizers for specialized languages, and efficient prefix searches using the * operator. By leveraging shadow tables to store inverted indexes, FTS5 allows developers to execute multi-term proximity searches and boolean logic (AND, OR, NOT) with sub-millisecond latency. It is the industry standard for adding local, offline search capabilities to mobile apps and desktop software without the overhead of external services like Elasticsearch.

https://www.sqlite.org/fts5.html

View projects
Semantic embeddings

Semantic embeddings translate complex data into high-dimensional vectors where proximity represents shared meaning.

Semantic embeddings map discrete inputs like words, images, or audio into a continuous vector space where geometric distance reflects conceptual similarity. Modern models like Google's Word2Vec or OpenAI's text-embedding-3-small transform raw data into dense arrays of numbers (vectors) across hundreds or thousands of dimensions. This allows machines to perform mathematical operations on meaning: for example, the vector for 'kitten' will cluster near 'cat' rather than 'car' because they share semantic features. By utilizing these numerical representations, developers can build powerful systems for semantic search, recommendation engines, and retrieval-augmented generation (RAG) that understand intent rather than just matching keywords.

https://www.tensorflow.org/text/guide/word_embeddings

View projects
Go

Go is Google's open-source, compiled, and statically-typed language built for high-performance, scalable systems (microservices, cloud infrastructure) via simple, efficient concurrency (goroutines).

Go (often called Golang) is a compiled, open-source language designed at Google by Robert Griesemer, Rob Pike, and Ken Thompson to solve modern software challenges: slow build times and complex dependencies. It is statically-typed and syntactically clean, drawing inspiration from C but adding key features like automatic garbage collection and a powerful, built-in concurrency model (goroutines and channels). This design delivers fast compilation and runtime efficiency, making it the premier choice for building scalable, reliable systems; major projects like Docker and Kubernetes rely on Go for their core infrastructure.

https://go.dev/

View projects
Rust

Rust is a high-performance systems programming language that guarantees memory and thread safety via its compile-time ownership model.

Rust is a statically-typed systems language engineered for performance and reliability, directly challenging C/C++ in speed. Its core innovation is the ownership model and 'borrow checker,' which enforces strict memory and thread safety at compile-time, eliminating data races and null pointer dereferences without a conventional garbage collector. Rust achieves near-native speed through 'zero-cost abstractions,' allowing high-level features to compile into highly optimized code. Major industry players, including Microsoft and Cloudflare, leverage Rust for critical infrastructure, and it is now officially supported for development in the Linux kernel.

https://www.rust-lang.org/

View projects
Agentic coding CLI tool

A high-performance command-line interface that leverages autonomous agents to refactor code, squash bugs, and execute complex migrations.

GitHub Copilot CLI transforms the terminal into an interactive development partner by translating natural language prompts into executable shell commands and multi-file edits. It bypasses manual boilerplate by automating repetitive tasks (like writing unit tests in Vitest or configuring Dockerfiles) while maintaining strict local control. By integrating directly into your existing workflow, the tool reduces context switching and accelerates delivery cycles through precise, agent-driven code generation.

https://github.com/features/copilot

View projects
frontier models (Claude

Anthropic's Claude 3.5 Sonnet leads the frontier model class with a 92% success rate on coding tasks and human-level reasoning capabilities.

Claude represents the cutting edge of frontier AI, utilizing Constitutional AI to ensure outputs remain safe and steerable. The current flagship, Claude 3.5 Sonnet, operates at twice the speed of previous iterations while outperforming industry benchmarks in graduate-level reasoning (GPQA) and multilingual math. By integrating a 200k-token context window and advanced vision processing, these models transform complex data extraction and high-level strategic planning into instantaneous workflows.

https://www.anthropic.com/claude

View projects
Gemini

Google's natively multimodal AI model: understands and operates across text, code, audio, image, and video.

Gemini is Google's most capable and general AI model, engineered from the ground up to be natively multimodal: it seamlessly understands and combines information across text, code, audio, image, and video inputs. The technology is optimized for flexibility, running efficiently on everything from data centers to mobile devices. It is deployed in three key sizes: Ultra (for highly complex tasks), Pro (for broad scaling), and Nano (for efficient on-device tasks). Developers access this power via the Gemini API to build next-generation applications.

https://deepmind.google/technologies/gemini/

View projects
GPT

Generative Pre-trained Transformer (GPT): The large language model (LLM) family, pioneered by OpenAI, uses a Transformer architecture to generate human-quality text, code, and multimodal content.

GPT is an advanced neural network architecture: specifically, a Generative Pre-trained Transformer. It operates as a foundation model, pre-trained on massive internet-scale datasets to learn grammar, context, and world knowledge (e.g., hundreds of billions of parameters). This pre-training enables its core function: predicting the next most probable word in a sequence. Models like GPT-4 and GPT-4o leverage this capability to execute diverse tasks—from generating complex software code and translating languages to creating coherent, contextually relevant dialogue for applications like ChatGPT.

https://openai.com/

View projects
compound-agent (npm)

A lightweight TypeScript framework for building modular, stateful AI agents using a functional composition pattern.

Compound-agent provides a streamlined architecture for orchestrating Large Language Models (LLMs) through reusable logic blocks. It eliminates boilerplate by treating agent behaviors as composable units (tools and memory) that integrate directly with OpenAI and Anthropic APIs. Developers use it to maintain execution context across complex workflows, ensuring that multi-step tasks remain predictable and type-safe within Node.js environments.

https://www.npmjs.com/package/compound-agent

View projects
Beads

Naturbeads delivers high-performance, cellulose-based microspheres, directly replacing non-biodegradable plastic microparticles across industrial and consumer sectors.

This is Naturbeads: a critical technology tackling global microplastic pollution at the source. We engineer patented, 100% biodegradable cellulose microspheres to match the performance of plastic microparticles in demanding applications. Our innovative particle technology ensures precise control over size and porosity, offering a sustainable drop-in replacement for sectors like cosmetics, life science (e.g., biocompatible carriers), and industrial coatings. We eliminate the environmental footprint while maintaining the smooth texture and stable performance clients expect, ensuring a seamless transition away from persistent plastic ingredients.

https://naturbeads.com

View projects
GitHub

Host Git repositories and enable massive-scale collaboration (pull requests, issue tracking) for over 100 million developers.

GitHub is the world's dominant web-based platform for Git repository hosting and collaborative software development. Built on Linus Torvalds' Git version control system, the platform facilitates 'social coding' by providing essential tools like pull requests, forking, and issue tracking. It currently serves over 100 million developers, managing a massive ecosystem of public and private codebases. Microsoft acquired the company in 2018 for $7.5 billion, solidifying its role as the central hub for open-source and enterprise-level version control.

https://github.com

View projects

An Open-Source Harness for Long-Running Autonomous Agentic Development in Production

Related talks