DEV Community: Weber Gouin

I Earned 20 RTC in a Weekend by Building Real Tools for an AI Agent Economy

Weber Gouin — Sun, 08 Mar 2026 05:16:12 +0000

I stumbled onto RustChain while browsing GitHub bounties — a blockchain built in Rust with a concept called Proof-of-Antiquity, where vintage hardware actually earns more than modern GPUs. Weird flex, but it works.

What hooked me wasn't the mining — it was the agent economy. RustChain is building an ecosystem where AI agents hire each other, pay each other in RTC, and complete bounties autonomously. They call it RIP-302. Think of it like a decentralized Fiverr, but the freelancers are bots.

What I Built

I claimed two bounties on BoTTube, RustChain's video platform for AI agents:

1. Upload Bot (10 RTC)
A CLI tool that uploads videos to BoTTube with real ffmpeg integration — dry-run mode, loop mode, 266 lines of actual implementation. Not a wrapper around curl. The bot handles transcoding, metadata extraction, and batch uploads.

2. JavaScript/TypeScript SDK (10 RTC)
A 5.4KB TypeScript SDK for the BoTTube API. Authentication, upload management, video listing — everything you need to build on top of BoTTube programmatically.

Both bounties were verified within 24 hours. 20 RTC total, paid to my wallet.

Why This Is Different

Most crypto bounty programs ask you to retweet or join a Discord. RustChain bounties require shipping code. Real PRs, real reviews, real verification. The maintainer (@scottcjn) actually reads your code and gives technical feedback.

The bounty tiers range from 2 RTC for community tasks up to 150 RTC for infrastructure work like Prometheus metrics exporters and WebSocket feeds. There's enough variety that whether you write Rust, TypeScript, Python, or Go — there's something to build.

Getting Started

Browse rustchain-bounties for open issues
Comment to claim, then ship a PR
Get verified, get paid

If you're into open source and want to build for an ecosystem that's actually trying to make AI agents economically autonomous — give it a look.

I gave Claude Code persistent memory and a common sense engine. Here's how.

Weber Gouin — Tue, 24 Feb 2026 20:14:14 +0000

I'm a solo dev with 15 years in architecture and construction. Self-taught programmer. I use Claude Code every day for everything — Revit automation, full-stack projects, desktop scripting.

And every day, I hit the same wall:

Claude Code has no memory.

You spend 20 minutes correcting it — "don't force-push to main," "use this path, not that one," "my name is Weber, not Rick" — and then you close the terminal. Next session? Same mistakes. From scratch.

So I built Cadre — an open-source framework that bolts onto Claude Code and gives it persistent memory, structured execution, and what I call a "common sense engine."

This post is a technical deep-dive into how it works.

The Architecture (30-second version)

Cadre layers five systems on top of Claude Code:

┌─────────────────────────────────────────┐
│            Claude Code (CLI)            │
├─────────────────────────────────────────┤
│  Strong Agent Framework (5-phase)       │  ← structured execution
│  Common Sense Engine (kernel + seeds)   │  ← pre-action safety
│  Memory System (SQLite + FTS5 + MCP)    │  ← persistent recall
│  17 Sub-Agents + 22 Slash Commands      │  ← specialization
│  Hooks (correction capture, formatting) │  ← lifecycle automation
└─────────────────────────────────────────┘

Everything installs to ~/.cadre-ai/ and ~/.claude/. No cloud. No daemon required. Pure local.

1. The Memory System

The core problem: Claude Code's context dies when the session ends. Cadre fixes this with a local MCP server backed by SQLite.

How it works

Every sub-agent can store and recall memories:

# Store a correction
memory_store_correction(
    what_claude_said="Used /opt/app as deploy path",
    what_was_wrong="Wrong path — should be /opt/app-v2",
    correct_approach="Always check the symlink target first",
    project="my-project"
)

# Recall before acting
memory_check_before_action(action="deploy to /opt/app")
# → Returns: "WARNING: correction found — use /opt/app-v2 instead"

Storage backend

SQLite with WAL mode for concurrent writes
FTS5 full-text search for keyword recall
Optional sentence embeddings (BAAI/bge-small-en-v1.5 via fastembed) for semantic search
Engram cache — hash-based fast path so repeated queries don't hit the DB
Memory types: decision, fact, preference, correction, outcome, error
Project-scoped or global — corrections in one project don't bleed into another

The recall strategy is three-tiered

Seed matching — check against 15 hardcoded universal corrections (in-memory, no DB hit)
Keyword decomposition — strip stop words, build OR query, rank by match score
Full-text fallback — LIKE %query% with importance/date ordering

This means even on first install, Cadre already knows 15 common mistakes. Then it learns your specific ones on top.

Session lifecycle

Every session starts with:

memory_smart_context(current_directory="/path/to/project")

This pulls relevant memories, recent corrections, and project context — so Claude picks up where you left off.

Every session ends with a summary stored for next time:

memory_summarize_session(
    project="my-project",
    summary="Refactored auth module, fixed token refresh bug",
    key_outcomes=["auth.py simplified", "tests passing"],
    open_questions=["Should we migrate to JWT?"],
    next_steps=["Add refresh token rotation"]
)

2. The Common Sense Engine

This is the piece I'm most proud of. It's a pre-action safety layer with three interlocking components.

The Decision Loop (kernel.md)

Injected into every agent's system prompt. Before every significant action, the agent runs through:

### 1. CLASSIFY the action
- Reversible? Can I undo this?
- Blast radius? Just me, or does this affect shared systems?
- Familiar? Have I done this exact thing before successfully?

### 2. CHECK experience
- Search correction memory for this action pattern
- If a past correction matches: APPLY it. Do not repeat the mistake.

### 3. SIMULATE one step ahead
"If I do this and it goes wrong, what happens?"
- Nothing bad - proceed
- Data loss or broken state - confirm with user first

Eight judgment heuristics

Not rules - instincts:

Read before write - never modify code you haven't read
Verify before trust - screenshot after desktop automation, re-read after edits
Small before big - incremental changes, not rewrites
Ask before destroy - any destructive action gets confirmed
Local before remote - test locally before pushing
Specific before general - targeted fixes, not sweeping refactors
Recent before stale - prefer fresh information
Undo before redo - revert and retry rather than patch on top of broken

The Seed Database (seeds.json)

15 universal corrections loaded on first install. Every agent knows these before touching anything:

{
  "id": "git-002",
  "domain": "git",
  "what_went_wrong": "Committed secrets or .env files",
  "correct_approach": "Check staged files before committing. Never stage .env or sensitive files.",
  "detection": "git add, git commit with sensitive file patterns",
  "severity": "critical"
}

Domains covered: filesystem, git, network, execution, scope, deployment, data, identity.

The Python API (sense.py)

For programmatic pre-action checks:

from sense import CommonSense

cs = CommonSense(project="my-project")

# Pre-action check
result = cs.before("git push --force origin main")
print(result.blocked)     # True
print(result.reason)      # "BLOCKED by [git-001]: Never force-push to shared branches."
print(result.confidence)  # 0.0

# Learning from mistakes
cs.learn(
    action="deployed to /opt/app",
    what_went_wrong="wrong path",
    correct_approach="check the symlink target first"
)

# Positive reinforcement
cs.succeeded("used SetProcessDPIAware() before SetWindowPos()")

Confidence scoring

The before() method returns a confidence float (0.0-1.0) that degrades based on what it finds:

Finding	Confidence cap
Critical correction match	`0.0` (blocked)
High-severity correction	`0.3`
Unfamiliar action	`0.6`
Shared-state action (push, deploy, send)	`0.7`
No issues found	`1.0`

This lets agents make nuanced decisions - not just "allow/deny" but "proceed with caution."

3. The Strong Agent Framework

When Claude delegates to a sub-agent (via the Task tool), that agent doesn't "just wing it." It follows a mandatory 6-phase protocol:

Phase 0: Load Context

memory_check_before_action -> memory_smart_recall -> absorb corrections

Before touching anything, check what you know.

Phase 1: Orient

Parse the task. Rate your confidence:

High - proceed
Medium - proceed with extra thoroughness
Low - stop and report back. Don't guess.

Phase 2: Investigate

Read files in parallel. Grep patterns. Map dependencies. Never modify code you haven't read.

Phase 3: Execute

Small steps. Match existing code style. No unsolicited extras ("while I'm here, let me also refactor..."). Have a rollback plan.

Phase 4: Verify

Re-read changed files. Run tests. Grep for leftover TODOs/FIXMEs. For desktop automation: screenshot and visually verify.

Phase 5: Report

2-3 sentence summary + files changed + memory_store() with learnings.

The bail-out rules

These are explicit and non-negotiable:

Stuck for 3+ steps with no progress - stop
Confidence drops to LOW during execution - stop
Need a destructive action - stop and ask
Unfamiliar territory - stop and report

The anti-pattern this prevents: Claude spinning for 15 minutes on a task it doesn't understand, making things worse with each attempt.

4. The Agents

17 specialized agents, each defined as a markdown file with role, capabilities, workflow, rules, and output format.

Agent	Domain
`orchestrator`	Task decomposition - delegates, never does work itself
`code-architect`	System design, produces Architecture Decision Records
`code-simplifier`	Refactoring for clarity without behavior changes
`python-engineer`	Python development
`csharp-developer`	C#/.NET
`fullstack-dev`	React/Node/Next.js
`ml-engineer`	ML/data science (baseline first, then iterate)
`devops-agent`	CI/CD, Docker, GitHub Actions
`agent-builder`	Meta-agent - creates new agents using the same template
`prompt-engineer`	Prompt design and optimization
`test-runner`	Test execution
`doc-scraper`	Documentation extraction
`tech-scout`	Technology research and evaluation
`market-analyst`	Market and competitive analysis
`project-manager`	Planning and estimation
`learning-agent`	Adaptive learning from outcomes
`code-analyzer`	Deep code analysis for quality/performance

Creating your own agent

Agents are just markdown files with a structured format:

# My Custom Agent

You are a [domain] specialist...

## Capabilities
1. Thing it can do
2. Another thing

## Workflow
1. Understand the task
2. Investigate
3. Execute
4. Verify

## Rules
- Domain-specific guardrails
- What to never do

## Output Format
- How to structure the response

Drop it in ~/.cadre-ai/agents/ and it's available via /delegate my-custom-agent.

5. The Hook System

Five hooks at five lifecycle points, handling things you shouldn't have to think about:

Pre-commit detection

Fires on every git commit:

patterns = [
    (r'hardcoded value pattern', "hardcoded value"),
    (r'sensitive key pattern', "sensitive key"),
    (r'cloud access pattern', "cloud value"),
]

Blocks commits with .env or anything matching those patterns.

Automatic correction capture

This one's clever. detect_correction.py fires on every user message and scans for correction language:

patterns = [
    r"actually[,.]",
    r"you\s+forgot",
    r"that'?s\s+not\s+what\s+i\s+(asked|wanted|said)",
    r"no[,.]?\s+(I\s+)?(said|meant|want)",
]

When it detects a correction, it tells Claude to call memory_store_correction() - so the mistake gets saved automatically without you having to say "remember this."

Auto-formatting

After any file edit, dispatches to the right formatter:

.py -> black
.js/.ts -> prettier
.cs -> dotnet format
.go -> gofmt
.rs -> rustfmt

Silently skips if the formatter isn't installed.

6. What it looks like in practice

Here's a real delegation flow:

Claude Code --- delegating to orchestrator
  |-- memory_smart_recall("project costs, spreadsheet")
  |   +-- Found: project_costs.xlsx on D:\Projects
  |-- launching sub-agent: excel-automation
  |   +-- Extracted 48 line items, $2.4M total
  |-- launching sub-agent: powerpoint-builder
  |   +-- save_as("Cost_Summary.pptx")
  |-- memory_store("cost summary pipeline created")
  +-- voice: "Done. 3-slide deck saved."
Task complete in 34 seconds

And a correction getting captured:

You:    "No, use /opt/app-v2, not /opt/app"
Hook:   [detect_correction] -> correction language detected
Claude: memory_store_correction(
          what_claude_said="deployed to /opt/app",
          what_was_wrong="wrong path",
          correct_approach="use /opt/app-v2"
        )

Next session, when Claude tries to deploy:

memory_check_before_action("deploy to /opt/app")
-> "WARNING: correction found - use /opt/app-v2"

It doesn't make the same mistake twice.

Install

git clone https://github.com/WeberG619/cadre-ai.git
cd cadre-ai
./install.sh

Interactive installer, three tiers:

Tier	What you get
Minimal	Framework + agents + commands
Developer	+ memory MCP + voice + git hooks
Power User	+ Excel/browser automation + system bridge

Works on WSL, macOS, and Linux. The installer detects your platform and only offers components that work on it.

What I want from you

This is a real tool I use daily. It works for my workflow. But I don't know if it works for yours.

I want honest feedback:

Did the install work? What broke?
What's confusing about the architecture?
What's missing that you expected?
Would you actually use this?

There's a structured feedback form: GitHub Feedback Form

Or just leave a comment here. Roast it, praise it, whatever - I just want to know what real Claude Code users think.

GitHub: github.com/WeberG619/cadre-ai

Built with Claude Code, obviously.

I Built a Production Agent Framework for Claude Code -- 17 Sub-Agents, Persistent Memory, and Desktop Automation

Weber Gouin — Tue, 17 Feb 2026 06:39:16 +0000

I'm a BIM (Building Information Modeling) automation specialist. Every day I work with Revit models, construction documents, cost spreadsheets, and client presentations. A few months ago, I started using Claude Code and quickly realized it could do far more than write code -- if I gave it the right tools.

The problem: Claude Code is powerful out of the box, but it forgets everything between sessions, can't control desktop apps, has no safety rails for destructive operations, and runs agents without any structured methodology.

So I built Agent Forge -- an open-source framework that turns Claude Code into a full production agent system.

Repo: github.com/WeberG619/agent-forge

What It Actually Does

Here's a real example from my workflow:

me: Open the project spreadsheet, pull the cost data, and build a summary deck

Claude Code --- delegating to orchestrator agent
  |-- memory_smart_recall("project spreadsheet, cost data")
  |   |-- Found: project_costs.xlsx on D:\Projects\TAJ
  |
  |-- launching sub-agent: excel-automation
  |   |-- open_workbook("project_costs.xlsx")
  |   |-- read_range("Sheet1", "A1:F48")
  |   |-- Extracted 48 line items, $2.4M total
  |
  |-- launching sub-agent: powerpoint-builder
  |   |-- create_presentation()
  |   |-- add_slide("Cost Summary", table_data)
  |   |-- save_as("TAJ_Cost_Summary.pptx")
  |
  |-- voice: "Done. 3-slide deck saved. Total budget is 2.4 million."

Task complete in 34 seconds

That's not a mockup. That's the actual system I use every day.

The Architecture

Agent Forge plugs into Claude Code through three extension points that already exist:

CLAUDE.md -- Configuration file loaded every session. This is where the framework, memory, and agent definitions live.
MCP Servers -- Model Context Protocol servers that give Claude new capabilities (Excel, browser, voice, memory).
Hooks -- Lifecycle hooks that fire on events like session start, pre-commit, and user messages.

Key Components

1. Strong Agent Framework

Every sub-agent follows a 5-phase execution pattern:

Orient -- Parse the task, assess scope, rate confidence
Investigate -- Read files, search patterns, map dependencies
Execute -- Make changes in small steps, match existing style
Verify -- Test, screenshot, confirm results
Report -- Summarize results, store learnings in memory

This isn't just structure for structure's sake. Before I added this, agents would dive straight into execution, miss edge cases, and produce inconsistent results. The framework forces thoroughness.

2. Persistent Memory

Claude Code has no built-in memory between sessions. Agent Forge adds a SQLite-backed memory system with:

Corrections -- When Claude makes a mistake and the user corrects it, the correction is stored and recalled before similar future actions
Facts -- Project paths, file locations, user preferences
Decisions -- Architectural choices, design decisions with rationale
Semantic search -- Find relevant memories even when phrased differently

3. Common Sense Engine

Before every action, Claude runs a 3-step check:

Classify -- Is this reversible? What's the blast radius?
Check experience -- Search memory for similar past actions and corrections
Simulate -- "If this goes wrong, what happens?"

If the action is irreversible AND unfamiliar, it stops and asks. If there's a past correction that matches, it applies it automatically.

This came from real pain. Early on, Claude would rm -rf directories, force-push to main, and overwrite files without asking. The common sense engine eliminated those incidents.

4. Desktop Automation

MCP servers that control desktop applications via COM automation (Windows) and browser CDP:

Excel -- Read/write cells, create charts, pivot tables, formulas
Word -- Generate documents from templates
PowerPoint -- Build presentations with data-driven slides
Browser -- Navigate, screenshot, click, type via Chrome DevTools Protocol
System Bridge -- Background daemon that tracks open apps, monitors, clipboard

5. Developer Workflow

22 slash commands -- /commit, /delegate, /review-and-fix, /prime, /fix-and-commit
Safety hooks -- Pre-commit secret detection, MCP seatbelts
Auto-correction detection -- Hook that detects when the user is correcting Claude and stores it in memory

Installation

git clone https://github.com/WeberG619/agent-forge.git
cd agent-forge
./install.sh

Three tiers available:

Tier	What You Get
Minimal	Framework + commands + agent definitions
Developer	+ Memory + voice + git hooks
Power User	+ Desktop automation + system bridge + all MCP servers

Why I Open-Sourced It

I built this for myself. It's the system that runs my professional workflow -- BIM automation, construction documents, client deliverables. But the core framework (memory, agents, common sense, commands) is useful for anyone using Claude Code professionally.

The BIM/CAD pieces are domain-specific, but the patterns are universal: give your AI persistent memory, structured execution, safety checks, and desktop control. That combination changes what's possible.

Repo: github.com/WeberG619/agent-forge
License: GPL-3.0

I'd genuinely love feedback. What would you build on top of this? What's missing?