Houston

OpenClaw for non-technical founders.
One desktop app. A workspace of pre-built AI agents that generate value from day one.
Real tools. 1000+ integrations. Trained on real tasks. Free forever.

gethouston.ai · Vision · Learn · Join the waiting list · @ja818_

For non-technical users — a free Mac app you download. Install a workspace built by someone else (a fundraising co-pilot, a sales outreach engine, a customer-support triage system) and you get real AI agents working for you on day one. No terminal. No prompt engineering. No 40-hour learning curve.

For developers — an open-source framework for building AI agent experiences. React packages for the UI, Rust crates for the engine. Your agent is a manifest + optional custom React. Publish it once, anyone can install it in one click.

For founders — the foundation of your vertical AI product. Fork Houston, rename it, ship a workspace specialized for your industry. Your code, your customers, your moat. Skip six months of plumbing and focus on the part that's actually different. We make money by hosting it for you 24/7 — the framework itself is free forever.

Read the full vision: Why AI-native workspaces — an essay on how every app is CRUD, why AI-as-a-feature has a ceiling, and what changes when humans and AI share all the operations on the same data.

Most AI products bolt a chat sidebar onto a SaaS app and call it AI. Houston agents are different.

• Real tools — agents read files, run code, send messages, hit APIs, edit documents. The same kind of operations a human teammate would do — not text snippets pretending to be actions.
• 1000+ integrations — Slack, Notion, Linear, Stripe, Gmail, HubSpot, Google Drive, GitHub, and a thousand more. Connect once, the agent works across all of them.
• Trained on real tasks — every agent in the store ships pre-configured for a specific job: outbound sequences, fundraising memos, ICP analysis, support triage. Real, tested playbooks — not generic prompting.
• Files-first architecture — agent-visible data lives in .houston/ files, not in a database. Agents read and write naturally; you can open the same files yourself in any text editor.
• Symmetric participation — both you and the AI can take any action. Click a button or ask in chat — same outcome, same data.

git clone https://github.com/ja-818/houston.git
cd houston
pnpm install
cd app && pnpm tauri dev

On first launch, create a workspace and an agent. Pick an agent definition (Project Manager, Research Agent, Code Reviewer, etc.) and start chatting with Claude.

npx create-houston-agent my-app
cd my-app
pnpm install
pnpm tauri dev

You get a working app with Chat + CLAUDE.md editor out of the box. Add @houston-ai components as you need them. The Learn guide walks through the full mental model in eight short chapters — written for developers who've built with AI before.

git clone https://github.com/ja-818/houston.git my-vertical-app
cd my-vertical-app
# Rename, rebrand, build on top

Your code, your customers, your moat. Free under MIT. If you hit something missing in the base framework, send it back as a PR. Get in touch when you're ready to scale.

Houston organizes work into Workspaces and Agents:

• Workspace — top-level container (like a team or project group). Each workspace has its own connections and agents.
• Agent — an AI agent instance powered by an agent definition. Each agent has a chat, optional kanban board, skills, files, and more.
• Agent Definition — defines what tabs and capabilities an agent has. Pick from built-in definitions or build your own.

Workspace ("My Startup")
  +-- Agent ("Growth Agent")          <- definition: Growth Agent
  |     Activity | Chat | Skills | Routines | Files
  +-- Agent ("Investor Relations")    <- definition: Investor Relations
  |     Activity | Chat | Context | Skills
  +-- Agent ("Sales Outreach")        <- definition: Sales Outreach
        Activity | Chat | Files | Skills

Each kanban card on the Activity tab is a Claude conversation. Click a card to see its full chat history. The agent's progress shows as a step-by-step checklist alongside the chat. Connect Slack and the same conversation becomes a thread — reply from your phone, the agent responds there too.

Agent definitions are JSON manifests that define what an AI agent looks like. Three tiers:

{
  "id": "growth-agent",
  "name": "Growth Agent",
  "description": "Competitor teardowns, outbound sequences, ICP analysis",
  "icon": "Zap",
  "tabs": [
    { "id": "activity", "label": "Activity", "builtIn": "board" },
    { "id": "chat", "label": "Chat", "builtIn": "chat" },
    { "id": "skills", "label": "Skills", "builtIn": "skills" },
    { "id": "routines", "label": "Routines", "builtIn": "routines" },
    { "id": "files", "label": "Files", "builtIn": "files" }
  ],
  "defaultTab": "activity",
  "systemPrompt": "You are a growth marketing expert...",
  "claudeMd": "# Growth Agent\n..."
}

Built-in tab types: chat, board, skills, files, connections, context, routines, channels, events, learnings

9 built-in agent definitions: Default, Project Manager, Meeting Assistant, Research Agent, Data Analyst, Code Reviewer, DevOps, Content Writer, Customer Support.

Installed agent definitions load from ~/.houston/agents/{id}/manifest.json.

Every Houston agent stores agent-visible data in a .houston/ folder:

~/Documents/Houston/{WorkspaceName}/{AgentName}/
  .houston/
    agent.json          # Agent metadata (id, manifest, timestamps)
    activity.json       # Kanban board items
    routines.json       # Recurring schedules
    goals.json          # High-level objectives
    channels.json       # Messaging integrations (Telegram, Slack)
    skills/             # Agent skill instructions
      research.md       #   ## Instructions + ## Learnings
    prompts/            # Editable system prompt components
      system.md         #   Base system prompt
      self-improvement.md
    log.jsonl           # Session audit trail
    config.json         # Project settings (model, effort)
  CLAUDE.md             # Agent instructions

The rule: if @houston-ai has a component that renders it, the data lives in .houston/. App-specific files go in their own folder.

Agents interact with these files directly — no CLI intermediary, no SQL queries. The agent_store module provides typed CRUD with atomic writes. Because everything lives in plain files, you can read and edit the same data yourself in any text editor, and the agent sees it instantly via the file watcher.

11 packages on @houston-ai/*. Generic, props-driven, no store lock-in. Use Zustand, Redux, Jotai — whatever you want.

The foundation. 38 shadcn/ui components, design tokens, animations, and base hooks.

Drop-in chat experience for Claude sessions. One component does streaming markdown, thinking blocks, tool activity, auto-scroll, and input.

Kanban board with animated cards that glow when agents are running.

App shell components.

Channel and service connection management.

Event feed for heartbeats, cron jobs, channel messages.

Recurring automated task management.

Agent skill management with community marketplace.

Review queue for completed agent work.

Agent file management.

Agent memory and learnings store.

8 crates on houston-*. The runtime your agent needs to actually do work.

Claude CLI session management. Spawns claude -p --output-format stream-json, parses NDJSON output, manages concurrency.

Minimal SQLite layer. Two tables: chat_feed and preferences. That's it — agent-visible data lives in files, not in the DB.

The integration layer. Wraps everything into Tauri 2 commands and state.

Channel adapters for messaging platforms.

Event queue for hooks, webhooks, and lifecycle events.

Cron jobs and heartbeat timer scheduling.

Agent memory store (evaluating for removal — most learnings now live in .houston/memory/).

+-------------------------------------------------------------+
|                Houston App / Your Tauri App                  |
|   Workspaces > Agents > Agent Definitions                   |
+------------------------+------------------------------------+
|                        |                                    |
|   Houston UI (React)   |   Houston Engine (Rust)            |
|                        |                                    |
|   @houston-ai/core     |   houston-tauri                    |
|   @houston-ai/chat     |     +-- agent_store (.houston/)    |
|   @houston-ai/board    |     +-- session_runner/queue       |
|   @houston-ai/layout   |     +-- channel_manager            |
|   @houston-ai/skills   |     +-- houston-sessions           |
|   @houston-ai/routines |     |     +-- Claude CLI process   |
|   @houston-ai/...      |     +-- houston-db                 |
|                        |           +-- chat_feed (SQLite)   |
|                        |                                    |
+------------------------+------------------------------------+
|                    Tauri 2 IPC Bridge                        |
+------------------------+------------------------------------+
|   .houston/ files      |   Claude Code / Codex / Other      |
|   (agent data)         |   (AI agent processes)             |
+------------------------+------------------------------------+

Houston UI components are props-driven with no store lock-in. Use Zustand, Redux, Jotai — whatever you want.

Houston Engine handles session lifecycle, agent file management, and channel routing. Agent-visible data lives in .houston/ files. SQLite is only for chat conversation replay.

Built on Claude Code — and on anything shaped like it. Claude Code is the default local agent runtime, but Houston works with Codex or any other coding agent that can read files, write files, and run commands inside a working directory.

Everything is controlled by CSS variables:

@theme {
  --color-primary: #0d0d0d;           /* Near-black (default) */
  --color-primary-foreground: #ffffff;
  --color-secondary: #f9f9f9;
  --color-muted-foreground: #5d5d5d;
  --color-border: rgba(0, 0, 0, 0.08);
}

Override --color-primary for brand theming. All components pick it up automatically.

houston/
├── app/                Houston app (Tauri 2) — the flagship desktop app
│   ├── src/            React frontend
│   └── src-tauri/      Rust backend
├── packages/           @houston-ai/* — 11 React packages
│   ├── core/
│   ├── chat/
│   ├── board/
│   ├── layout/
│   ├── connections/
│   ├── events/
│   ├── memory/
│   ├── routines/
│   ├── skills/
│   ├── review/
│   └── agent/
├── crates/             houston-* — 8 Rust crates
│   ├── houston-sessions/
│   ├── houston-db/
│   ├── houston-tauri/
│   ├── houston-channels/
│   ├── houston-events/
│   ├── houston-scheduler/
│   └── houston-memory/
├── create-app/         create-houston-agent — scaffolding template
├── showcase/           Component showcase — live demos for all @houston-ai components
└── redirect-page/      gethouston.ai — landing + vision essay + learn guide

• gethouston.ai — landing page
• Vision essay — Why AI-native workspaces (the why behind Houston)
• Learn guide — Eight chapters on building Houston apps (the how)
• Join the waiting list — Get notified when the app ships
• skills.sh — Community AI skills marketplace
• @ja818_ on X — Updates and announcements

Teach your coding agent how to build with Houston:

npx skills add ja-818/houston

Browse on skills.sh.

Building something on Houston? Open a PR to add it here.

Houston is open source under MIT. Issues and PRs welcome — for big architectural changes, open an issue first to discuss the direction.

MIT