Architecture to Autonomy All apps
Open source · Apache-2.0

Neural Seed

Self-hosted AI deal discovery for solo operators: angels, scouts, and sector-focused VCs. It reads public signals, extracts company and founder data with Claude, and scores everything against a Markdown thesis you write and version yourself. Thesis-as-code, transparent scoring, no data-provider lock-in.

3 Signal sources
0 Keys in demo mode
5 Pipeline stages
Apache‑2.0 License

What it does

four steps

Deal sourcing for a solo investor is mostly reading. Neural Seed does the first pass: it watches public signals, turns unstructured posts into structured company records, and ranks them against the thesis you actually invest on.

1

Ingests public signals

GitHub trending, Hacker News “Show HN”, and any RSS feeds you configure. An in-process scheduler runs GitHub trending daily and Show HN hourly.

2

Extracts structured data

Claude pulls company and founder records out of the raw posts using tool-use at temperature=0, and the prompt hashes are stored alongside the result.

3

Scores against your thesis

Each company is scored against a Markdown thesis you control. It ships with theses/devinfra-v1.md as a worked example; fork it and write your own rubric.

4

Surfaces a ranked pipeline

A server-rendered web UI shows the ranked pipeline, plus a daily brief printed to stdout: the top three companies scoring 7.0 or above in the last 24 hours.

Thesis-as-code

auditable by construction

The interesting design decision is that the thesis is a file, not a setting buried in a UI. That makes the scoring reviewable, diffable, and versioned like any other artifact.

Your rubric, in Markdown

Theses are Markdown with a YAML front-matter block. Copy the bundled one, rewrite the prose and the weights, and point the app at it with an environment variable. The five axes themselves — market, team, traction, fit, timing — are a fixed set in this phase; you control their weights and what they mean, not their names.

Versions are content-addressed

Scores are keyed on {name}-{version}-{sha256(body)[:8]}, so editing the body of the thesis mints a new version and leaves earlier scores intact. Scores are append-only, so re-scoring adds a row rather than overwriting one.

Every score is traceable

A score points back to the exact prompt bytes, the model version, and the source documents that produced it. You can always ask why a company ranked where it did.

No provider lock-in

Signals come from public sources you can inspect rather than a paid data vendor, and the whole stack runs on your own machine.

Quick start

demo mode needs no keys

Demo mode needs no API keys. It generates a deterministic synthetic dataset of 52 companies, clearly flagged as demo data, so you can walk the pipeline before wiring anything up.

# demo mode - no API keys required cp .env.example .env docker compose up -d postgres # make install migrates, so the DB must be up make install # uv sync + alembic upgrade + tailwind build make demo # seeds the demo DB and starts the api # then open http://localhost:8000 # full mode - set NEURAL_SEED_DEMO=0, ANTHROPIC_API_KEY, GITHUB_TOKEN docker compose up -d postgres make install make run

To use your own thesis, copy theses/devinfra-v1.md, edit the rubric, then set NEURAL_SEED_THESIS=my-thesis-v1 and run again.

Run it on localhost only. The project ships with no authentication and its README is explicit about this: do not expose it to the public internet. Treat it as a single-operator tool on your own machine.

Architecture

five stages
Sources ──► Ingestion ──► Storage ──► Intelligence ──► Surface (connectors) (scheduler) (Postgres) (enrichment + (api + ui + scoring) briefs)

The stack is deliberately boring and self-hostable:

Python 3.12 + uv FastAPI Jinja (server-rendered) Tailwind Postgres 16 + pgvector SQLAlchemy 2.0 async Alembic APScheduler Claude (anthropic SDK) Voyage embeddings

Full mode needs an ANTHROPIC_API_KEY, a GITHUB_TOKEN and a VOYAGE_API_KEY, plus Postgres running via Docker Compose. Design notes, the data model, and the LLM contracts are documented in DESIGN.md in the repo.

What this is, and is not

read before you judge it

The repo describes itself as a Phase 1 vertical slice, and its own contributing guide calls it an experimental project. That framing is worth taking at face value: the end-to-end loop is real code with a real schema and offline tests, but it is a reference architecture rather than a finished product.

Genuinely implemented

The ingest → extract → score → UI loop, three connectors, seven Postgres tables, forced tool-use extraction, and the provenance discipline: content hashes for dedup, prompt and thesis hashes stamped on every score row, and append-only scores.

Configured but not wired

SMTP settings exist but the daily brief only prints to stdout. Langfuse variables exist but nothing reads them. Embeddings are computed and indexed, but nothing queries them yet, so there is no semantic search in this phase.

Deliberately out of scope

Authentication, multi-tenancy, multiple simultaneous theses, knowledge graphs, multi-agent diligence, and paid data providers are all named non-goals for this phase, not oversights.

No results claimed

There are no benchmarks, cost measurements, or accuracy evaluations in the repo, and none are implied here. Entity resolution is exact-name matching by design, with fuzzy matching deferred.

Open repo All apps Connect on LinkedIn

Views expressed here are my own and do not represent the views of any current or former employer, client, or affiliated organization.