DEV Community: Travis Cole

"Stop Treating All AI Memories the Same — Introducing Cortex, Who Forgot?"

Travis Cole — Wed, 04 Feb 2026 19:52:06 +0000

A quick fact ("PostgreSQL runs on port 5432") is not the same as a learned pattern ("always use connection pooling for high-traffic services").

A deployment event is not the same as a user preference.

So why do most memory systems treat them identically?

The Problem with Flat Memory

Most AI memory solutions — RAG, vector stores, simple key-value caches — dump everything into the same bucket. A one-time debug note sits next to a critical architectural decision with the same priority, the same retrieval weight, the same lifespan.

The result? Bloated context windows full of irrelevant noise. Your AI retrieves a bug fix from 6 months ago with the same confidence as a pattern you use daily.

Cortex: Cognitive Classification for AI Memory

Titan Memory includes Cortex — a multi-stage classifier that routes every incoming memory into one of five cognitive categories:

Category	What It Stores	Decay Rate
Knowledge	Facts, definitions, technical info	Slow — facts persist
Profile	Preferences, settings, user context	Very slow — preferences stick
Event	Sessions, deployments, incidents	Fast — events age out
Behavior	Patterns, habits, workflows	Slow — patterns are valuable
Skill	Techniques, solutions, best practices	Very slow — skills are durable

Each category decays at a different rate. An error you hit last Tuesday fades. A deployment pattern you've used across 5 projects persists.

The Librarian Pipeline

On recall, Cortex doesn't just return the top-K vectors. It runs a full refinement pipeline:

Retrieve top candidates via hybrid search (dense vectors + BM25)
Split into individual sentences
Score every sentence with a 0.6B parameter semantic encoder
Prune anything below relevance threshold
Resolve temporal conflicts (newer info wins)
Check category coverage — balanced recall, not just highest embeddings

The result: 70-80% token compression on every recall. Only gold sentences reach your LLM.

How It Actually Works

# One command to install
claude mcp add titan-memory -- node ~/.claude/titan-memory/bin/titan-mcp.js

Store a memory:

titan_add("Always use connection pooling for high-traffic Postgres services")
→ Classified: Skill (confidence: 0.94)
→ Routed to Layer 4 (Semantic Memory)
→ Decay half-life: 270 days

Store an event:

titan_add("Deployed v2.3 to production, rolled back due to memory leak")
→ Classified: Event (confidence: 0.91)
→ Routed to Layer 5 (Episodic Memory)
→ Decay half-life: 90 days

Recall later:

titan_recall("Postgres performance best practices")
→ Returns the connection pooling skill (still strong after 6 months)
→ The deployment event has decayed — unless you specifically ask for events

That's how human memory works. Different types of information, stored differently, retrieved differently, forgotten at different rates. We just gave that to AI.

The Bigger Picture

Titan Memory is a 5-layer cognitive memory system delivered as an MCP server:

Layer 1: Working Memory (your context window)
Layer 2: Factual Memory (O(1) hash lookup, sub-10ms)
Layer 3: Long-Term Memory (surprise-filtered, adaptive decay)
Layer 4: Semantic Memory (patterns, reasoning chains)
Layer 5: Episodic Memory (session logs, timestamps)

Cortex is just one piece. There's also semantic highlighting, surprise-based storage filtering, hybrid search with RRF reranking, and cross-project pattern transfer.

914 passing tests. Works with Claude Code, Cursor, or any MCP-compatible client.

Built With Less

I definitely can't contend for compute like the rest of the 99.9%. But we can all strive for sustainability and AI safety.

This system was coded entirely by Opus 4.5, and the research was done with Opus 4.5 and Google's DeepMind in a Queen swarm pattern. All the architectural decisions were my own, and all the countless hours of researching and reading and staying awake for far too many hours at a time were all on my own.

This project shows that you don't always have to build bigger or be bigger to get the best outcome. This is evidence that you can get a lot out of a little compute and solve countless problems.

Now go build something great.

100% FREE, no paywall, all the sauce in one bottle.

GitHub: github.com/TC407-api/titan-memory

License: Apache 2.0

Title: Don't Fry Your Computer! Date: 2026-01-25 Description: Best practices for running AI agents safely. Author: Timothy C

Travis Cole — Sun, 25 Jan 2026 19:53:47 +0000

Reddit is full of horror stories lately. Developers giving Claude Code or Cursor unrestricted access, only to watch helplessly as the AI decides to "clean up" their home directory. Lost projects. Corrupted systems. Deleted files that took years to accumulate.

This isn't fear-mongering—it's the reality of working with AI agents in 2026. Here's how to stay safe.

The Problem

AI coding assistants like Claude Code, Cursor, and GitHub Copilot are incredibly powerful. They can write code, run shell commands, edit files, and navigate your entire filesystem. That power is a double-edged sword.

The issue isn't that these tools are malicious. The issue is that they:

Follow instructions literally - "Clean up this directory" can mean different things to different entities
Lack context about consequences - An AI doesn't know that .env file contains your only copy of production credentials
Can chain actions unexpectedly - A simple refactoring task might cascade into system-wide changes
Make mistakes - Just like humans, but sometimes faster

Never give an AI agent unrestricted access to your system. The convenience isn't worth the risk.

Horror Stories from the Community

These are real incidents reported by developers:

The Recursive Delete

A developer asked Claude to "remove all test files from this project." The AI interpreted this broadly, recursively deleting anything with "test" in the filename—including the user's ~/Documents/test_projects/ folder containing six months of work.

The Helpful Cleanup

One user's AI decided to "optimize" their system by removing "unnecessary" dotfiles. Gone were .bashrc, .gitconfig, and years of carefully curated configurations.

The Production Wipe

A developer running an AI agent with database access asked it to "reset the test database." Unfortunately, the AI couldn't distinguish between test and production environments. You can guess what happened next.

The Infinite Loop

An agent tasked with "fixing all TypeScript errors" entered an infinite loop of making changes, creating new errors, then "fixing" those. It ran for eight hours before the developer noticed, leaving the codebase in an unrecognizable state.

Why This Happens

Most AI safety incidents stem from a few common patterns:

1. Unrestricted Permissions

# What NOT to do
claude --dangerously-skip-permissions "refactor my entire codebase"

The --dangerously-skip-permissions flag exists for a reason—it's dangerous. Every time you bypass permission checks, you're betting that the AI will do exactly what you meant, not what you said.

2. Unclear or Ambiguous Prompts

"Clean up the code" could mean:

Remove commented-out code
Delete unused files
Restructure directories
All of the above, recursively, including things you didn't want touched

Be explicit. Be specific. Be paranoid.

3. No Escape Hatch

When you let an AI agent run autonomously without checkpoints, you're flying without a parachute. By the time you notice something's wrong, the damage might be irreversible.

4. Working on Production Data

Never let an AI agent touch production systems directly. Not even "just to check something."

Best Practices

1. Always Use Sandboxed Environments

The single most important security measure is isolation. Options include:

Docker Containers:

# Create an isolated environment
docker run -it --rm \
  -v $(pwd):/workspace \
  -w /workspace \
  your-dev-image

# Now run your AI agent inside this container

Virtual Machines:

Use tools like Multipass, Vagrant, or cloud instances
Snapshot before any AI-assisted work
Easy rollback if things go wrong

Git Worktrees:

# Create an isolated worktree
git worktree add ../project-experiment feature-branch

# Work there, merge only what you verify

2. Set Explicit Permission Boundaries

Claude Code has a permissions system for a reason. Use it:

# Restrict to specific directories
claude --allow-dir ./src --allow-dir ./tests

# Deny dangerous operations
claude --deny-pattern "rm -rf" --deny-pattern "DROP TABLE"

Start with minimal permissions and add more only as needed. It's easier to grant access than to undo damage.

3. Review Commands Before Execution

Enable confirmation mode for anything destructive:

# Claude Code with confirmations
claude --confirm-before-execute

Yes, it's slower. Yes, it interrupts your flow. Yes, it's worth it.

4. Implement Checkpoint Strategies

Before any significant AI-assisted work:

# Create a git checkpoint
git add -A && git commit -m "checkpoint: before AI refactoring"

# Or create a system snapshot
# On macOS with Time Machine, on Linux with snapper, etc.

5. Use Dry-Run Modes

Many tools support dry-run or preview modes:

# Git operations
git clean -fd --dry-run

# File operations
rsync -avz --dry-run source/ destination/

# Database migrations
migrate --dry-run

6. Monitor and Limit Execution Time

Set timeouts for AI operations:

# Limit execution time
timeout 5m claude "fix the TypeScript errors in src/"

# Monitor for runaway processes
watch -n 1 'ps aux | grep claude'

7. Separate Environments Strictly

Maintain strict separation between:

Development
Staging
Production

Never give AI agents credentials or access to production. If they need to understand production data, provide sanitized samples.

Claude Code Specific Tips

Understanding the Permission System

Claude Code asks for permission before:

Writing files outside the current directory
Running shell commands
Accessing the network
Reading sensitive files

Don't bypass these checks. They're your safety net.

Safe Default Configuration

Create a .claude/settings.json in your project:

{
  "permissions": {
    "allowedPaths": ["./src", "./tests", "./docs"],
    "deniedPatterns": ["*.env*", "*.pem", "*.key"],
    "confirmDestructive": true,
    "maxFilesPerOperation": 10
  }
}

The Yolo Mode Problem

"Yolo mode" or unrestricted execution is tempting when you're in flow state. Resist the temptation. The five seconds you save on confirmations aren't worth the risk of catastrophic data loss.

Read-Only Sessions

For exploration or code review:

# Start Claude in read-only mode
claude --read-only "explain how the authentication system works"

Recovery Strategies

If something goes wrong:

Immediate Actions

Stop the agent - Ctrl+C, kill the process, whatever works
Don't panic - Assess before acting
Check git status - See what changed
Review logs - Understand what happened

Git Recovery

# See what changed
git diff HEAD

# Partial rollback
git checkout -- specific-file.ts

# Full rollback
git reset --hard HEAD

# Recover deleted untracked files (maybe)
git fsck --lost-found

File Recovery

Check your trash/recycle bin first
Use file recovery tools (TestDisk, PhotoRec)
Restore from backup (you have backups, right?)

Database Recovery

Point-in-time recovery from backups
Transaction log replay
Contact your DBA immediately for production issues

The Mental Model

Think of AI agents like a very capable but very literal junior developer with root access.

Would you give a new hire unrestricted access to production? Would you let them run commands without review? Would you leave them unsupervised on critical systems?

Apply the same judgment to AI tools.

Conclusion

AI-assisted development is genuinely transformative. Claude and similar tools can dramatically accelerate your work and help you solve problems faster than ever before.

But with great power comes great responsibility. The developers who thrive with AI tools are the ones who:

Treat AI suggestions as drafts, not final answers
Maintain strong backup and version control habits
Use sandboxing and isolation by default
Never bypass permission systems
Stay engaged and verify results

Don't let Claude fry your computer. Use these tools wisely, and they'll serve you well. Use them carelessly, and you might become the next cautionary tale on Reddit.

The goal isn't to avoid AI tools—it's to use them safely. Start small, build trust through verification, and gradually expand permissions as you understand the tool's behavior.

Stay safe out there. And always, always have backups.

Why Your AI Agents Fail in Production (And How to Fix It)

Travis Cole — Sun, 18 Jan 2026 07:33:25 +0000

## TL;DR

I built Task Orchestrator, an open-source MCP server that adds production safety to Claude Code agents. It catches semantic failures (hallucinations, wrong answers) not just crashes, learns from
mistakes, and prevents recurrence.

GitHub: github.com/TC407-api/task-orchestrator

MIT licensed
680+ tests
Provider-agnostic (works with any LLM)

## The Problem

Here's a stat that should terrify anyone deploying AI agents:

"Less than 1 in 3 teams are satisfied with their AI agent guardrails and observability" - Cleanlab AI Agents Report 2025

I've been building with Claude Code for months. It's incredible for development velocity. But here's what I noticed:

Agents hallucinate file paths that don't exist
They suggest fixes that introduce new bugs
They claim "tests pass" without running them
Same errors happen again and again

The tools exist to catch crashes. Nothing exists to catch semantic failures.

## The Math Problem

At 95% reliability per step, a 20-step agent workflow has only a 36% success rate overall.

0.95^20 = 0.358 = 35.8%

That's not a bug - it's compound probability. Every step that could fail, will eventually fail.

## What I Built

Task Orchestrator is an MCP server that adds an immune system to Claude Code:

### 1. Semantic Failure Detection

Not "did it crash?" but "did it actually do the right thing?"

### 2. ML-Powered Learning

The system learns from failures. Pattern stored -> warning before similar prompts.

### 3. Human-in-the-Loop

High-risk operations queue for human approval.

### 4. Cost Tracking

Know what you're spending across providers.

### 5. Self-Healing

Circuit breakers that back off automatically.

## Getting Started

git clone https://github.com/TC407-api/task-orchestrator.git
cd task-orchestrator && pip install -r requirements.txt
cp .env.example .env.local
claude mcp add task-orchestrator python mcp_server.py

Restart Claude Code. Done.

## What's Next

Core is free forever. For teams that need more, enterprise features are in development - see the roadmap for details.

I'm committed to maintaining and improving this project as long as there's interest. This isn't abandonware.

I want your input:

What features would improve your AI agent workflows?
What problems are you running into that this could solve?

GitHub: github.com/TC407-api/task-orchestrator

Star if you think AI agents need better safety.

Built by someone tired of AI agents failing silently.

This post was written with Claude Code, but all thoughts, ideas, and architecture decisions are my own - the result of countless hours of research, experimentation, and real-world frustration.