Kayba vs Theta

The Short Answer

Both Kayba and Theta help agents improve over time, but they take fundamentally different approaches to what "learning" means. Theta is memory-first -- agents accumulate memories from past interactions and retrieve them later. Kayba is learning-first -- execution traces are analyzed to extract structured skills that rewrite the agent's prompts.

Theta gives agents memory. Kayba gives agents skills.

What Each Tool Does

Theta

Theta (YC X25) positions itself as "agents that remember & learn" through a memory-based approach:

• Memory persistence: Agents store memories from past interactions and retrieve them in future runs
• Self-learning as a side effect: As memories accumulate, the agent's behavior changes because its context includes more past experience
• Memory-first architecture: The core primitive is the memory store, not a learning loop
• Managed service: Closed-source platform handling memory storage and retrieval

Theta's framing blurs the line between memory and learning. Remembering what happened is not the same as understanding why something failed and extracting a reusable lesson from it -- but accumulated memories can shift behavior over time.

Kayba

Kayba is an open-source learning layer (MIT, 2k+ stars) that synthesizes three published research papers into a unified framework:

• Recursive Reflector: REPL-based trace analysis that programmatically examines agent execution -- grounded in the ACE framework (arXiv:2510.04618) and Reflective LLM Methods (arXiv:2512.24601)
• Skill extraction: Failures and successes are distilled into atomic, reusable skills with helpful/harmful counters
• Skillbook: A persistent, transparent collection of everything the agent has learned -- organized, auditable, with provenance tracking back to source traces. Inspired by the Dynamic Cheatsheet approach (arXiv:2504.07952)
• Prompt generation: Approved skills are compiled into optimized system prompts
• Continuous learning: Delta updates refine the Skillbook incrementally as new traces come in

The framework is agent-agnostic and requires no fine-tuning -- it works by improving the context your agent receives, not by retraining weights.

The Key Difference: Memory vs. Reflection

Theta's learning model is memory accumulation. The agent stores what happened, and retrieval-augmented generation surfaces relevant memories at inference time. Learning is implicit -- the agent behaves differently because it has more memories to draw on, not because it has distilled those memories into structured knowledge.

Kayba's learning model is structured reflection. The Recursive Reflector analyzes execution traces to understand why something succeeded or failed, then extracts that understanding into discrete skills. Those skills are curated (approved, edited, or rejected by a human) and compiled into improved prompts.

This is the difference between episodic memory and procedural memory:

Memory accumulation has a ceiling. As the memory store grows, retrieval quality degrades -- the agent has to find the right memories among thousands. Kayba's Skillbook distills patterns into compact, reusable skills that are compiled into prompts, keeping the agent's context focused and curated rather than bloated.

Comparison

Benchmarks

Kayba's trace-based approach is validated on public benchmarks:

• t2-bench: pass@1 improvement of +27.4%, scaling to +100% at pass@4
• Browser agents: Success rate from 30% to 100%, with 82% fewer steps and 65% lower costs

These results come from the published research papers and are reproducible with the open-source framework. Theta has not published benchmark results at the time of writing.

When to Choose Theta

Theta may be a fit if:

• Your primary need is memory persistence -- agents that remember past conversations and user preferences across sessions
• You want a managed memory service without building your own storage and retrieval layer
• Episodic recall is more important than structured skill extraction for your use case
• You're comfortable with a closed-source platform

When to Choose Kayba

Kayba is the stronger choice if:

• You need agents that learn from their mistakes, not just remember them
• Auditability matters -- every improvement traces back to a specific execution, a specific failure, a specific skill
• You want structured, curated knowledge (Skillbook) rather than a growing memory store
• You want to own your learning data and run on your own infrastructure
• Open source is important -- inspect the code, contribute, fork if needed
• You want research-backed methods with published, reproducible results

Using Together

Memory and learning are complementary. Theta's memory layer could provide episodic context while Kayba's Skillbook provides procedural knowledge -- the agent remembers what happened (Theta) and knows what to do about it (Kayba). If Theta exposes an API for memory storage, it could serve as one input source alongside Kayba's trace analysis pipeline.

Getting Started

Kayba is open-source and ready to use today:

pip install ace-framework

• Documentation -- Setup guides and API reference
• GitHub -- Source code and examples
• Dashboard -- Hosted version with visual Skillbook management