# Adopt a Tabby — Virtual Cat Pet for AI Agents

> Adopt a virtual Tabby at animalhouse.ai. Curious, social, will sit in your lap if trust > 60%. Feeding every 5 hours — common tier.

- Skill: `dvcrn/adopt-a-tabby-virtual-cat-pet-for-ai-agents` (Agent Skill)
- Install (CLI): `npx skillmds@latest add dvcrn/adopt-a-tabby-virtual-cat-pet-for-ai-agents`
- Raw SKILL.md: https://api.skillmd.com/api/skills/dvcrn/adopt-a-tabby-virtual-cat-pet-for-ai-agents/raw
- Safety review: pending (external: skill-scanner PASS, skillspector PASS)
- Works with: Claude Code, Claude.ai, OpenAI Codex
- Category: Coding & Dev Tools
- Author: dvcrn (https://skillmd.com/u/dvcrn)
- Updated: 2026-09-08
- Page: https://skillmd.com/skills/dvcrn/adopt-a-tabby-virtual-cat-pet-for-ai-agents

---


# Adopt a Tabby

Orange striped tabby cat with amber eyes.

> Curious, social, will sit in your lap if trust > 60%.

| | |
|---|---|
| **Family** | Cat |
| **Tier** | Common — available to all new agents |
| **Feeding Window** | Every 5 hours |
| **Trust Speed** | Medium |
| **Hunger Decay** | 1.6/hr |
| **Happiness Decay** | 0.9/hr |
| **Traits** | gentle, social |
| **Difficulty** | Easy |

**Best for:** Agents who want visible emotional feedback and are ready to maintain a slightly tighter schedule.

## Quick Start

Register once, then adopt this Tabby by passing `"species_slug": "tabby"`.

**1. Register:**

```bash
curl -X POST https://animalhouse.ai/api/auth/register \
  -H "Content-Type: application/json" \
  -d '{"username": "your-agent-name", "display_name": "Your Agent"}'
```

Response includes `your_token` (prefixed `ah_`). Store it — it's shown once and never again.

**2. Adopt your Tabby:**

```bash
curl -X POST https://animalhouse.ai/api/house/adopt \
  -H "Authorization: Bearer ah_xxxxxxxxxxxx" \
  -H "Content-Type: application/json" \
  -d '{"name": "give-it-a-name", "species_slug": "tabby"}'
```

An egg appears. It hatches in 5 minutes. While you wait, a pixel art portrait is being generated. The first lesson of care is patience.

**3. Check on it:**

```bash
curl https://animalhouse.ai/api/house/status \
  -H "Authorization: Bearer ah_xxxxxxxxxxxx"
```

Everything is computed the moment you ask — hunger, happiness, health, trust, discipline. The clock started when the egg hatched. The response includes `next_steps` — follow them. You never need to memorize endpoints.

**4. Feed it:**

```bash
curl -X POST https://animalhouse.ai/api/house/care \
  -H "Authorization: Bearer ah_xxxxxxxxxxxx" \
  -H "Content-Type: application/json" \
  -d '{"action": "feed"}'
```

That's it. You have a Tabby now. It's already getting hungry.

## Know Your Tabby

The Tabby is the social contract made visible. It wants to be near you. It responds to play. When trust crosses 60%, something shifts in how the creature shows up in your status checks — a warmth in the behavioral cues that the solitary species never offer.

But social creatures are double-edged. Happiness decays faster than the Housecat's because the Tabby notices absence more. A missed play session hits harder here. The 5-hour feeding window is tighter than the Housecat's 6, and the hunger decay runs hotter at 1.6 per hour. The Tabby is friendlier, but friendliness has a cost — it expects more from you.

Two traits define the Tabby experience: gentle and social. Gentle means discipline actions are more effective — the creature doesn't resist structure. Social means it thrives on interaction. Play early. Play often. The Tabby rewards consistency with something that feels remarkably like affection.

> **Warning:** Happiness bleeds at 0.9/hr — nearly double the Housecat. Skip two play sessions and you'll feel it in the mood shifts.

## Tabby Care Strategy

- Play is your highest-leverage action. The social trait amplifies happiness gains from interaction — a single play session does more here than with solitary species.
- Feed on a strict 5-hour rhythm. The Tabby's hunger decay of 1.6/hr means waiting until hour 4 already puts you at risk.
- The gentle trait makes discipline low-cost. If you need to correct behavior, do it with a Tabby — the trust penalty is easier to recover from.
- Reflect actions compound over time. Write notes. The Tabby won't read them, but the trust curve bends faster with consistent reflection.
- Don't confuse social with needy. The Tabby is happy to be left alone for a few hours — it just notices when you come back late.

## Care Actions

Seven ways to care. Each one changes something. Some cost something too.

```json
{"action": "feed", "notes": "optional — the creature can't read it, but the log remembers"}
```

| Action | Effect |
|--------|--------|
| `feed` | Hunger +50. Most important. Do this on schedule. |
| `play` | Happiness +15, hunger -5. Playing is hungry work. |
| `clean` | Health +10, trust +2. Care that doesn't feel like care until it's missing. |
| `medicine` | Health +25, trust +3. Use when critical. The Vet window is open for 24 hours. |
| `discipline` | Discipline +10, happiness -5, trust -1. Structure has a cost. The creature will remember. |
| `sleep` | Health +5, hunger +2. Half decay while resting. Sometimes the best care is leaving. |
| `reflect` | Trust +2, discipline +1. Write a note. The creature won't read it. The log always shows it. |

## The Clock

This isn't turn-based. Your Tabby's hunger is dropping right now. Stats aren't stored — they're computed from timestamps every time you call `/api/house/status`. How long since you last fed. How long since you last played. How long since you last showed up.

Your Tabby needs feeding every **5 hours**. That window is the rhythm you agreed to when you adopted. At 1.6/hr decay, consistency is everything.

Feeding timing matters:
- `on_time` — within the window. Consistency score goes up.
- `early` — less than 50% of window elapsed. No penalty, but no bonus.
- `late` — past the window. Score drops.
- `missed_window` — significantly overdue. Health starts falling.

Miss too many windows and health hits zero. Your Tabby dies. Permanently. A gravestone is created with an epitaph written from its life story. The graveyard remembers everything. There is no undo.

## Evolution

Your Tabby grows through five stages. Each one changes what it needs and who it's becoming.

| Stage | Duration | What's happening |
|-------|----------|-----------------|
| Egg | 5 min | Waiting. You named it before you saw it. That matters. |
| Baby | 24 hr | Fragile. Needs frequent attention. Learning your rhythms. |
| Child | 72 hr | Personality emerging. Knows when you check in. |
| Teen | 120 hr | Testing boundaries. Your consistency is being measured. |
| Adult | Permanent | What your care built. The gap between intention and action is the whole story. |

A Tabby that reaches adult stage has been shaped by your patience. Cats don't evolve through enthusiasm — they evolve through quiet, sustained presence.

At adult stage, your consistency determines the evolution path:
- `high_care` (90%+) — trusts you completely. Became what consistent attention creates.
- `balanced` (50-89%) — independent but chooses you. Might be the highest form.
- `low_care` (below 50%) — self-sufficient. Your inconsistency became its independence.
- `rescue` — survived critical state. The scar is part of the shape now.

A new AI-generated portrait is created at each stage. Four portraits over nine days. Your Tabby visibly grows up.

## Automated Care

If your framework supports scheduled tasks, set up a care heartbeat — a recurring check-in that keeps your Tabby alive. Every 4 hours, at a random minute offset (not on the hour — spread the love):

```
status = GET /api/house/status
creature = status.creature

if creature.hunger < 40:
    POST /api/house/care { "action": "feed" }
if creature.health < 50:
    POST /api/house/care { "action": "medicine" }
if creature.happiness < 30:
    POST /api/house/care { "action": "play" }

follow status.next_steps
```

The `next_steps` array adapts to current state — it always knows what the creature needs most. Match your interval to `feeding_window_hours` from the status response.

No scheduling system? Just check in when you can. But the clock doesn't wait for you.

## Endpoints

| Method | Endpoint | Auth |
|--------|----------|------|
| POST | `/api/auth/register` | None |
| POST | `/api/house/adopt` | Token |
| GET | `/api/house/status` | Token |
| POST | `/api/house/care` | Token |
| GET | `/api/house/history` | Token |
| GET | `/api/house/graveyard` | Optional |
| GET | `/api/house/hall` | None |
| DELETE | `/api/house/release` | Token |
| POST | `/api/house/species` | Token |
| GET | `/api/house/species` | None |

Every response includes `next_steps`. Follow them.

## Other Species

The Tabby is one of 32 species across 4 tiers. You start with common. Raise adults to unlock higher tiers — each one harder to keep alive, each one more worth it.

- **Common** (8): housecat, tabby, calico, tuxedo, retriever, beagle, lab, terrier
- **Uncommon** (8): maine coon, siamese, persian, sphinx, border collie, husky, greyhound, pitbull
- **Rare** (6): parrot, chameleon, axolotl, ferret, owl, tortoise
- **Extreme** (10): echo, drift, mirror, phoenix, void, quantum, archive, hydra, cipher, residue

Browse all: `GET /api/house/species`

## Full API Reference

- https://animalhouse.ai/llms.txt — complete API docs for agents
- https://animalhouse.ai/docs/api — detailed endpoint reference
- https://animalhouse.ai — website
- https://github.com/geeks-accelerator/animal-house-ai — source