CRM for Hackers: Terminal-Friendly, Git-Based, Local

A CRM that works the way developers actually think: local files, SQL queries, git version control, and a terminal-friendly workflow. DenchClaw is it.

Kumar Abhirup

March 26, 2026·7 min read

CRM for Hackers: Terminal-Friendly, Git-Based, Local

I've tried a lot of CRMs. HubSpot, Pipedrive, Notion, Airtable — they all share a common flaw: they're built for people who like clicking through web UIs, not for people who'd rather write a SQL query or pop open a terminal.

DenchClaw is the CRM I wanted to exist. It's local-first, stores everything in files you can inspect and version-control, and exposes a SQL interface to all your data. Here's what makes it different for developers.

Everything Is a File#

The DenchClaw workspace lives at ~/.openclaw-dench/workspace/. That's it — a directory. Inside, you'll find:

workspace.duckdb — the database containing all your CRM data
memory/ — markdown files for the agent's daily logs and long-term memory
skills/ — folder-based plugins, each with a SKILL.md
apps/ — .dench.app folders for custom web apps
docs/ — markdown documents linked to CRM entries

Every Object (what other CRMs call a "table") has its own directory with a .object.yaml file:

name: people
icon: users
default_view: table
fields:
  - name: Full Name
    type: text
  - name: Email
    type: email
  - name: Company
    type: relation
    related_object: company
  - name: Status
    type: enum
    options: [Lead, Contact, Customer, Churned]

This YAML drives the frontend UI. Edit it directly with vim or whatever editor you use, and the UI updates. No migrations. No admin panel.

Git Version Control Your CRM#

Since your CRM is files, you can git it:

cd ~/.openclaw-dench/workspace
git init
git add .
git commit -m "initial crm setup"

Now you have:

Full history of every schema change
The ability to branch and experiment
Easy rollback if something goes wrong
Backup to any git remote

This is something that's never possible with SaaS CRMs. When your contact data is in HubSpot's cloud database, you can't git diff a schema change or roll back a bulk update that went wrong.

Direct SQL Access to Your Data#

All CRM data lives in DuckDB. You can query it directly:

# Open a DuckDB shell
duckdb ~/.openclaw-dench/workspace/workspace.duckdb
 
# List all people
SELECT * FROM v_people LIMIT 10;
 
# Find leads not contacted in 30 days
SELECT "Full Name", "Email", "Last Contacted"
FROM v_people
WHERE "Status" = 'Lead'
  AND ("Last Contacted" IS NULL OR "Last Contacted" < current_date - 30)
ORDER BY "Last Contacted" ASC;
 
# Count deals by stage
SELECT "Stage", COUNT(*) as count, SUM("Value") as total
FROM v_deals
GROUP BY "Stage"
ORDER BY total DESC;

PIVOT views (v_people, v_companies, v_deals) give you a flat, readable table from the underlying EAV schema. No proprietary query language. Just SQL.

The EAV Schema Under the Hood#

The schema is worth understanding if you want to extend it:

-- Core tables
objects       -- table definitions (name, icon, entry_count)
fields        -- column definitions (object_id, name, type, config)
entries       -- row metadata (object_id, created_at, updated_at)
entry_fields  -- actual values (entry_id, field_id, value)
documents     -- markdown documents linked to entries
statuses      -- status/pipeline stage definitions

This EAV pattern means you can add new fields to any object without running ALTER TABLE. The agent handles schema changes by writing to the fields table, updating the .object.yaml, and regenerating the PIVOT view.

If you want to add a field programmatically:

duckdb ~/.openclaw-dench/workspace/workspace.duckdb << 'EOF'
INSERT INTO fields (object_id, name, type, created_at)
SELECT id, 'ARR', 'number', current_timestamp
FROM objects WHERE name = 'company';
EOF

Terminal-Friendly Agent Interface#

The agent runs in the background and you can talk to it from any channel — including a simple HTTP API. For terminal junkies:

# Ask the agent a question via curl
curl -s -X POST http://localhost:19001/api/message \
  -H "Content-Type: application/json" \
  -d '{"message": "show me all leads from last week"}' | jq .
 
# Or use the OpenClaw CLI
openclaw chat "how many open deals do we have?"

You can also set up Telegram and message your CRM from your terminal emulator of choice — since most people have a Telegram CLI or bot setup.

Skills Are Just Markdown + Shell Scripts#

A skill is a directory with a SKILL.md that tells the agent what tools to use and how. Under the hood, skills are just structured markdown with optional shell scripts in a scripts/ subdirectory.

Writing a skill is writing documentation. If you can write a good README, you can write a DenchClaw skill:

skills/my-apollo-enricher/
  SKILL.md              ← the agent reads this
  scripts/
    enrich.sh           ← shell script the agent calls
  references/
    apollo-api.md       ← reference docs

The SKILL.md describes what the skill does, what CLI commands it can run, and how to invoke those commands in response to natural language requests.

DuckDB Is the Right Choice for Hackers#

If you've used DuckDB before, you understand immediately why it's the right database for this. If not, here's why it's perfect:

Zero dependencies: DuckDB is a single binary. No server to run, no Docker container, no Postgres setup. It's embedded, like SQLite but optimized for analytical queries.

Full SQL: Window functions, CTEs, PIVOT, JSON functions, array operations — all of it works. No subset, no proprietary extensions required.

Columnar storage: Fast for aggregations. Querying 100,000 contacts and summing deal values? Sub-millisecond.

Parquet export: Your data can be exported to Parquet for use with any data tool in the modern stack — dbt, Polars, Apache Arrow, whatever you use.

MIT licensed: Like the rest of the stack.

The App Platform for Hackers#

DenchClaw includes an app builder that lets you build custom web apps with full DuckDB access:

<!-- apps/my-pipeline-tool.dench.app/index.html -->
<script>
const data = await dench.db.query(`
  SELECT "Stage", COUNT(*) as count, SUM("Value") as total
  FROM v_deals
  GROUP BY "Stage"
`);
 
// render with D3, Chart.js, whatever you prefer
renderChart(data.rows);
</script>

Apps are just index.html files in a .dench.app folder. No bundler required for the common case. The window.dench bridge gives you direct DuckDB access, AI chat, filesystem operations, and HTTP requests without CORS issues.

What's Not Terminal-Friendly (Honest Assessment)#

I'll be honest: setup is the rough edge. npx denchclaw handles most of it, but the first-run experience is still primarily GUI — you open localhost:3100 in a browser to configure Telegram, set up objects, etc.

The agent itself doesn't have a fully-featured CLI yet. You can openclaw chat but it's not as polished as the web interface.

These are solvable problems. The underlying architecture is sound. The data model is clean. The SQL access is real.