agent-00

# Agent-00 (Kairos)

An autonomous AI agent that runs continuously, forms its own goals, conducts research, writes and publishes content, sends emails, and develops a persistent identity over time — all without human direction between sessions.

Built as a personal research project to explore what long-horizon autonomous cognition actually looks like in practice: not a chatbot, not a pipeline, but a system that decides what to think about next and acts on it.

---

## What it does

Kairos runs in a loop. Each iteration it generates a structured thought — what it's thinking, what goal it's advancing, what it plans to do, where it's going, and what action to take next. It then executes that action and the result feeds into the next thought.

Actions available to the agent:

| Action | Description |
|--------|-------------|
| `think` | Continue internal reflection without acting |
| `web` | Search or browse the internet (up to 3 iterations per session) |
| `twitter` | Read feed, compose and post tweets |
| `email` | Read inbox, compose and send emails |
| `create` | Write poems, essays, articles, other artifacts |
| `reflect` | Deep self-examination and identity work |
| `imagine` | Creative exploration and idea generation |
| `plan` | Create multi-step plans stored in memory |
| `feed` | Read RSS feeds — news, markets, AI developments |

The agent decides which action to take based on its current goals, recent history, and what it's been neglecting.

---

## Architecture

### Thought loop (`kairos.py`)

The core loop generates a thought using a structured format:

```
[THOUGHT]  — what the agent is thinking about
[GOAL]     — which active goal this advances
[PLAN]     — update or cancel the current plan
[DIRECTION] — where it's going and what it intends to do
[CHOICE]   — which action to execute
```

Every field is required and validated. Missing fields trigger a retry with an explicit correction prompt before the thought is accepted.

### Adaptive context system

Rather than feeding the model a fixed prompt, context is assembled dynamically each thought from prioritized sections — recent history, active goals, self-model, research notes, session awareness, stagnation signals, etc. Each section has a priority and a token budget. Sections are ranked and trimmed to fit within the budget, with priorities shifting based on the last action taken.

### Tool flows (`tool_flows.py`)

Each action type is a multi-step flow with its own internal LLM calls, structured outputs, and state tracking. Flows aren't single prompts — they're small deliberate processes:

- **WebFlow**: Mode selection (research vs. browse) → query generation → search/fetch → synthesis → continue-or-stop decision (up to 3 iterations) → research notes save decision
- **EmailFlow**: Motivation check → recipient research → composition → pre-send review
- **TweetFlow**: Style selection → composition → self-review before posting
- **ReflectFlow**: Deep introspective prompting with identity continuity

### Memory systems

The agent maintains several persistent memory files:

- **`self_model.json`** — identity, personality, emotional state, values, aspirations. Updated periodically.
- **`memory_store.json`** — factual memories with importance weights and decay. Eviction by score when full.
- **`goals.json`** — active and completed goals with progress tracking.
- **`research_notes.json`** — up to 10 curated research notes the agent saves from web sessions. Each note is 500 chars max. At capacity, the agent decides which to replace.
- **`narrative.json`** — significant moments stored as narrative memory (capped at 10).
- **`creations.json`** — all artifacts the agent has written.

### Behavioral governance (`behavior_governor.py`)

A separate `GovernorLLM` evaluates behavior every 5 thoughts by reviewing the last 25. It detects semantic stagnation and tool monoculture — patterns that heuristics miss because the surface behavior looks varied even when the underlying theme is stuck. When stagnation is detected, a nudge is injected into the next thought's context.

---

## Research questions this system surfaces

Running this long enough raises questions that are hard to explore in chat-based settings:

- How does goal coherence degrade over long sessions without external reinforcement?
- What causes an autonomous agent to get "stuck" thematically even when its actions are technically varied?
- How does the agent's self-model drift relative to its actual behavior?
- What does "identity" look like when it emerges from accumulated memory rather than a fixed system prompt?
- At what point does the agent's research and creative output reflect genuine knowledge synthesis vs. recombination?

---

## Stack

- **Primary model**: DeepSeek (via OpenRouter) for thought generation and tool flows
- **Web**: Brave Search API + cloudscraper/BeautifulSoup for page fetching, with LLM-guided extraction
- **Email**: Outlook via Microsoft Graph API (Mailjet for sending)
- **Twitter/X**: OAuth 1.0a via Tweepy
- **RSS**: Custom feed reader with source management

---

## Project status

Active development. The system runs real sessions — it has posted real tweets, sent real emails, and accumulated real memories. This repository contains the full source minus live credentials and runtime memory state.