Deep Tech Scorer
itsbrendandang/deeptech-scorer
Score deep tech companies com rubric híbrido: IA pesquisa, Python pondera
Ver no GitHubCLI que avalia empresas de deep tech contra um rubric transparente e ajustável, combinando pesquisa com IA (Claude + busca web) com scoring determinístico baseado em dados públicos (SEC EDGAR, Google Trends). Separa coleta fuzzy de fatos da pontuação auditável, garantindo resultados reproduzíveis e pesos inspecionáveis.
Instalação
npx convez-ai itsbrendandang/deeptech-scorer1 comando no terminal: detecta o formato do repositório (marketplace ou plugin avulso) e instala via Claude Code. Requer Node 18+ e o Claude Code instalado.
Métricas
Casos de uso
- Avaliar viabilidade técnica e mercado de startups deep tech
- Due diligence fundamentado em dados públicos e rubric estruturado
- Comparar portfólio de empresas deep tech com critérios consistentes
- Tomar decisões de investimento com scoring auditável e tunable
Veredito

Excelente ferramenta para investidores e analistas que precisam de rigor na avaliação de deep tech. A separação clara entre coleta fuzzy (LLM) e scoring determinístico (rubric YAML) é arquiteturalmente sólida e rara — mantém auditabilidade sem sacrificar inteligência contextual. Requer Python 3.12+ e API key Anthropic para modo completo, mas funciona sem chaves em modo manual ou com dados públicos.
README
A tradução para o português deste README ainda está na fila.
dtscore — deep tech company & market evaluator
A CLI that scores any deep tech company against a transparent, deep-tech-specific rubric and answers one question directly: is this even good for the market?
It is hybrid: Claude (with web search) auto-pulls the messy facts — market size, funding, TRL, competitors, regulatory path — and proposes a score per dimension with evidence. Deterministic code (not the model) does the weighted rollup, so the final number is consistent, auditable, and tunable. You can override anything by hand.
What this demonstrates (engineering notes): a deliberate split between fuzzy and deterministic work — an LLM gathers messy facts, but a fixed, auditable rubric does the scoring, so results are reproducible and the weights are inspectable. It integrates real public data (SEC EDGAR Form D for funding, Google Trends for demand), keeps a clean signal → score → report separation, degrades gracefully with no API key/network, and ships with tests.
How it works
┌─ gather (Claude + web search) ─┐
│ research company & market │┐
│ facts + 0-10 scores + evidence ││
└────────────────────────────────┘│ ┌─ score (pure Python) ─┐
needs ANTHROPIC_API_KEY ├─→ │ weighted rollup │
┌─ signals (free public data) ───┐│ │ market-fit subscore │ → report (terminal + .md)
│ funding <- SEC EDGAR Form D ││ │ red flags + verdict │
│ market <- Google Trends │┘ └───────────────────────┘
└────────────────────────────────┘
no API key needed
Three inputs feed the same deterministic scorer. Per dimension the engine takes, in order: a manual override, then a manual/LLM score, then a data-backed signal, then 0 if nothing is known. So hard data fills gaps but never silently overrides your judgment.
The rubric (rubric.yaml) is the brain: 9 dimensions, fixed weights summing to 100,
and explicit 0/3/5/8/10 anchors. Edit it and every future score reflects the change.
Every dimension is scored so higher is always better (a 10 on capital-intensity
means cheap/fast; a 10 on regulatory-risk means a clean path).
| Pillar | Dimensions |
|---|---|
| Market (40) | market size & growth, why-now timing, customer pull |
| Moat (32) | 10x advantage, IP/data, technology readiness (TRL) |
| Execution (28) | capital efficiency, regulatory/scientific risk, team fit |
The market-fit subscore (the "good for the market?" answer) is a weighted blend of market size, timing, customer pull, and moat.
Usage
cd ~/deeptech-scorer
# One-shot: research + score (needs a key)
export ANTHROPIC_API_KEY=sk-ant-...
./dtscore run "Commonwealth Fusion" --market "grid-scale fusion power"
# Just pull a profile (saved to companies/<slug>.yaml), edit, then score
./dtscore gather "HelixFerm" --market "animal-free dairy" --notes "Series B, 2 LOIs"
./dtscore score companies/helixferm.yaml --save-md
# Fully manual — no key needed
./dtscore new mycompany --company "My Co" --market "..." # blank template to fill in
./dtscore score companies/mycompany.yaml
# Pull data-backed funding + market signals (no key needed)
./dtscore signals companies/cfs.yaml --cik 0001744079 --keyword "fusion energy" \
--tam 40000000000 --cagr 6 --competitors 12 --capital-needed 3000000000 --score
# Inspect or tune the framework
./dtscore rubric
Commands score, new, rubric, and signals work with no API key.
Only gather / run call Claude. (signals needs network for EDGAR/Trends.)
Data-backed signals
dtscore signals <profile> computes two composite scores from free public
data and writes them into the profile (plus per-dimension hints that fill any
unscored dimension):
Funding health (SEC EDGAR Form D, no key):
- largest reported amount sold, number of Form D filings, recency (momentum)
- investor quality: named investors matched against a curated allowlist in
signals/funding.py(editSTRATEGIC_INVESTORS) - optional capital adequacy:
--capital-neededvs. raised - maps to the
capital_intensitydimension
Market attractiveness (Google Trends + your numbers):
- size (log-scaled TAM), growth (CAGR), competitive density (U-shaped on
--competitors), and live search-interest momentum from Google Trends - maps to
market_sizeandmarket_timing
EDGAR name search is noisy (it returns SPVs and funds), so pass --cik to pin
the right filer. Run ./dtscore signals "<name>" with no --cik first and it
prints the candidate CIKs. Set a real contact in SEC_EDGAR_UA (EDGAR asks for
one): export SEC_EDGAR_UA="dtscore (you@example.com)".
Overrides
Trust your own judgment over the model on any dimension — pin it in the profile:
overrides:
capital_intensity: 3 # forces this dimension to 3, marked * in the report
Missing dimensions score 0 (gaps hurt the score rather than silently flattering it) and are listed at the bottom of the report.
Files
rubric.yaml— dimensions, weights, anchors, verdict bands (edit this to tune the model)gather.py— Claude + web search → structured profile (modelclaude-opus-4-8, adaptive thinking)signals/funding.py— SEC EDGAR Form D → funding-health signal (stdlib only)signals/market.py— Google Trends + size/growth/competition → market signalscoring.py— deterministic weighted scoring engine (no model calls)report.py— terminal + markdown rendering, deterministic market verdictdtscore.py/dtscore— CLI and wrappertests/test_signals.py— offline tests for the deterministic mappers + precedencecompanies/— saved profiles (YAML, hand-editable) ·reports/— generated markdowncompanies/helixferm.yaml— a worked example you can score right now
Notes & honesty
- The model proposes per-dimension scores; the rollup math is fixed code, so the overall number can't drift from the weights. But the inputs are still model judgments — treat auto-pulled facts as leads to verify, not ground truth.
- Designed to evaluate any deep tech company, including your own.
- Setup:
python3 -m venv .venv && ./.venv/bin/pip install -r requirements.txt(already done here).
Roadmap
- Crunchbase + PitchBook integration (planned). Add these paid data sources to enrich
the funding and market signals beyond the free SEC EDGAR + Google Trends layer: full
round history, named investors with lead/follow detail, post-money valuations, and
funded-competitor counts (today these are entered by hand, e.g. via
--competitors). They would feed the same deterministic scorers — more inputs, same transparent rollup.
License
MIT — see LICENSE. Built by Brendan Dang.