A self-building knowledge graph agent. Merges the autonomous loop pattern from Ralph with the graph memory engine from Cortex.
Tasty is an agent that loops autonomously, discovering and storing knowledge into a living graph. Each iteration enriches the graph — auto-linking related concepts, decaying stale info, and generating briefings that inform future iterations. The graph builds itself over time.
┌─────────────────────────────────────────────────────────┐
│ TASTY AGENT LOOP │
│ │
│ ┌──────────┐ ┌──────────┐ ┌──────────────────┐ │
│ │ 1. Brief │───▶│ 2. Think │───▶│ 3. Discover │ │
│ │ (Cortex │ │ (Plan │ │ (Explore source │ │
│ │ briefing)│ │ next │ │ material, run │ │
│ │ │ │ moves) │ │ tools, read) │ │
│ └──────────┘ └──────────┘ └────────┬─────────┘ │
│ ▲ │ │
│ │ ┌──────────┐ ┌────────▼─────────┐ │
│ │ │ 5. Link │◀───│ 4. Store │ │
│ └──────────│ (Auto- │ │ (Create nodes │ │
│ │ linking │ │ & edges in │ │
│ │ + decay)│ │ Cortex graph) │ │
│ └──────────┘ └──────────────────┘ │
│ │
│ Each iteration = fresh context, persistent graph │
│ Inspired by Ralph (github.com/snarktank/ralph) │
│ Powered by Cortex (github.com/MikeSquared-Agency/cortex)│
└─────────────────────────────────────────────────────────┘
The Loop (from Ralph)
Like Ralph, each iteration spawns a fresh agent instance with clean context. Memory persists not in the agent's context window, but in the graph. This means:
- No context window overflow — the graph is the memory
- Each iteration starts with a Cortex briefing — a tailored summary of what matters right now
- Progress is tracked via the graph itself, not a flat file
- The agent can run indefinitely, growing smarter with each loop
The Graph (from Cortex)
Instead of storing progress in progress.txt and prd.json like Ralph, Tasty uses Cortex's graph memory:
- Nodes — facts, decisions, discoveries, questions, tasks
- Edges — relationships discovered automatically via embedding similarity
- Decay — unused knowledge fades, important knowledge persists
- Briefings — each iteration starts with "what do I need to know?"
- Hybrid search — vector similarity × graph proximity
- Python 3.10+
- Cortex installed and running
- An LLM API key (OpenAI, Anthropic, or local)
git clone https://github.com/robot-rubik/tasty.git
cd tasty
pip install -r requirements.txtcp config.example.toml config.toml
# Edit config.toml with your settings# Start Cortex first
cortex init
cortex serve
# Run Tasty with a seed topic
python tasty.py --seed "Learn about the authentication system in this codebase"
# Or run the bash loop (Ralph-style) for autonomous operation
./tasty.sh --max-iterations 20 --seed "Map out the entire API surface"[cortex]
host = "localhost"
port = 9090
agent_name = "tasty"
[llm]
provider = "openai" # openai | anthropic | local
model = "gpt-4o"
api_key_env = "OPENAI_API_KEY"
[loop]
max_iterations = 50
min_new_nodes_per_iteration = 1
stop_on_no_discoveries = true
briefing_token_budget = 2000
[graph]
default_importance = 0.5
discovery_importance = 0.7
decision_importance = 0.8
question_importance = 0.6
decay_enabled = true
auto_link_threshold = 0.75Each iteration follows this cycle:
The agent requests a Cortex briefing — a synthesized summary of the most relevant knowledge for the current task context. This replaces Ralph's progress.txt with a dynamic, context-aware summary.
Using the briefing + the seed directive, the agent decides what to explore next. It checks the graph for gaps — topics mentioned but not explored, questions asked but not answered, contradictions to resolve.
The agent explores: reads files, searches codebases, calls APIs, or processes documents. Each piece of new information becomes a potential graph node.
Discoveries are stored as typed Cortex nodes:
fact— verified information ("The API uses JWT auth")decision— architectural decisions ("We chose PostgreSQL for X reason")question— open questions ("Why is this endpoint rate-limited?")task— things to do ("Need to document the webhook flow")insight— patterns and connections ("Module A and B share a common interface pattern")
Cortex auto-links new nodes to existing ones based on embedding similarity. The agent can also create explicit edges for strong relationships. Over time, the graph becomes a rich web of interconnected knowledge.
tasty/
├── tasty.py # Main entry point & CLI
├── tasty.sh # Bash loop runner (Ralph-style)
├── agent/
│ ├── __init__.py
│ ├── core.py # Agent core logic — the think/discover/store cycle
│ ├── planner.py # Plans what to explore next based on graph gaps
│ ├── discoverer.py # Explores sources and extracts knowledge
│ └── prompts.py # System prompts for the agent
├── graph/
│ ├── __init__.py
│ ├── client.py # Cortex client wrapper
│ ├── schema.py # Node/edge type definitions
│ └── briefing.py # Briefing generation and parsing
├── tools/
│ ├── __init__.py
│ ├── file_reader.py # Read and analyze files
│ ├── code_search.py # Search codebases
│ └── web_fetch.py # Fetch and parse web content
├── config.py # Configuration management
├── config.example.toml # Example configuration
├── requirements.txt
├── CLAUDE.md # Instructions for Claude Code
├── AGENTS.md # Instructions for Amp
└── README.md
Since Tasty uses Cortex, you get the built-in graph visualizer for free:
# Open in browser
open http://localhost:9091/vizWatch your knowledge graph grow in real-time as Tasty explores and discovers.
-
Ralph — The autonomous agent loop pattern. Ralph showed that AI agents work best when each iteration is a fresh context with persistent external memory. Tasty takes this further by replacing flat-file memory with a graph.
-
Cortex — The graph memory engine. Cortex provides the typed nodes, auto-linking, decay, and briefing synthesis that makes the graph self-organizing. Tasty is essentially a Ralph-style loop that feeds a Cortex graph.
-
Geoffrey Huntley's Ralph article — The original insight that spawned the autonomous loop pattern.
MIT