StockValuation.io Local Valuation Workflow
Turns a ticker into an inspectable Damodaran-style DCF: a local MCP service runs the deterministic math while your agent handles research, evidence, and judgment — assumptions stay transparent and challengeable.
The skill itself is restrained: valuation math is delegated to a local MCP service; the model is barred from authoring numbers, secrets are never requested in chat, bypasses require explicit user requests recorded via gate_records, and a no-advice policy is enforced. Deducted for: README recommends a curl|bash remote installer, the report auto-opens the browser by default (though --no-open exists), data flows involve external services (SEC/Yahoo) with an unverified publisher, and rollback paths are only partially described.
Real CI workflows and committed tests exist covering key paths (accounting validation, anchors, gates, range output); failure codes (GATE_NOT_CLEARED, UNANCHORED_SCENARIO_VALUE, explain_failure) are self-consistent and diagnosable. Deducted for: static review cannot execute; test coverage of the full eight-step workflow described in SKILL.md is incomplete; availability of Docker/Java services and external data sources is unverified.
Trigger conditions are explicit (mentions of stockvaluation.io or valuation requests); coverage boundaries, stop rules (financial firms, private companies, insufficient data), and non-fit ranges are clearly documented. Deducted for: core function depends entirely on overseas services (SEC EDGAR, Yahoo) with poor reachability from mainland China, no Chinese-language support, and a Docker requirement that raises the environment barrier.
Documentation is well layered (SKILL.md plus seven references with clear progressive disclosure), Apache-2.0 license is explicit, and the author is named with a non-affiliation disclaimer for Damodaran. Deducted for: version mismatch between SKILL.md (3.0.0-workflow-consistency) and pyproject (0.1.0), no changelog, maintenance responsibility and update path only implicit in a personal-project README.
Output contracts are tightly specified (report JSON shape, deterministic prose linter, numeric provenance labels, range-output rules) and the marginal-value claim (auditable Damodaran-style process) is clear. Deducted for: static review cannot verify actual output quality; value depends on a local Java service and external data chain, so representative outputs could not be confirmed directly usable.
CI workflows and committed test suites provide auditable material, including a byte-identical determinism test for anchors. Deducted for: coverage falls short of all key paths claimed in SKILL.md, no independent third-party reproduction, demo video unverifiable statically, and the static-review cap of 5 applies.
- The core data chain depends on SEC EDGAR and Yahoo, which may be unreachable from mainland-China networks; no Chinese-language support is declared.
- The README-recommended curl|bash installer executes unreviewed code on the user's machine; prefer cloning and reviewing locally before running.
- The report auto-opens the browser by default; use --no-open or STOCKVALUATION_OPEN_REPORT=0 for automation.
- Output is an educational valuation scenario, not financial advice; every material assumption requires human review.
- Version mismatch between SKILL.md and pyproject; this was a static review with no tests executed, so runtime quality remains unverified.
What does this skill do, and when should you use it?
StockValuation.io is an open-source, local-first valuation workflow for Codex and Claude. It separates responsibilities: the agent researches the company, reads filings, gathers evidence, and asks guided questions; a local MCP service runs the DCF math and returns auditable numbers; the user reviews assumptions and makes the final call. The workflow follows Damodaran's story-to-numbers methodology and enforces server-side gates — an evidence review must happen before scenario-bearing recalculations, and material drivers are pinned through guided questions. Reports are explicitly educational and not financial advice. It suits anyone who wants to learn or pressure-test DCF valuation and is willing to run a local service.
Starting from a ticker or an SEC EDGAR prospectus URL: it calls local MCP tools for a deterministic baseline (researched_baseline / value_ticker / extract_prospectus); the agent researches the company and builds driver-specific evidence packets; the run pauses at an evidence-review gate for user confirmation; plan_guided_questions poses guided assumption questions one at a time and applies the answers; the local service — never hand computation — recalculates baseline and low/base/high scenarios; finally build_report.py generates an HTML report with a deterministic prose linter and opens it automatically. Cases without sufficient data return an explicit failure instead of a fabricated valuation.
- A valuation learner who wants to see how a company's growth story maps item by item onto revenue growth, margin, reinvestment, and terminal-value assumptions
- A self-directed investor checking whether a DCF assumption holds up rather than accepting a black-box fair value
- A user needing to extract facts from an SEC prospectus (e.g., a SpaceX-type filing) and build a valuation view of a pre-public company
- A developer building and testing an agent-native valuation stack on Codex or Claude
- A teaching setting comparing how bearish, base, and bullish scenarios move the valuation
What are this skill's strengths and limitations?
- Valuation math is fully local, deterministic, and auditable; assumptions are transparent and challengeable rather than hidden
- Server-enforced gates prevent the agent from skipping evidence review or inventing scenario numbers (UNANCHORED_SCENARIO_VALUE and similar protections)
- Follows Damodaran's story-to-numbers method; reports show the assumption chain, not just a conclusion
- Returns a clear failure instead of a fake valuation when data cannot support one
- Requires installing and running a local Docker MCP service — a non-trivial deployment step
- Educational use only; explicitly prohibits investment advice and buy/sell/hold language; no financial-sector company support
- Local-first but not fully offline: market data, filings, currency data, and the model provider still need external access
- Non-US names, ADRs, IFRS, and unusual filings may need extra source review; historical coverage has gaps
- The author states no affiliation with or endorsement by Aswath Damodaran; the README shows no test suite or independent accuracy validation
How do you install this skill?
Requires Docker Desktop or a compatible Docker Engine with Compose. Two options: 1) from a local checkout, run ./install.sh setup; 2) remote install: curl -fsSL https://raw.githubusercontent.com/stockvaluation-io/stockvaluation_io/main/install.sh | bash -s -- setup. The installer sets up the skill, configures local tools, starts Docker services, and prints status, targeting Codex and Claude by default. The curl installer clones to ~/.local/share/stockvaluation_io by default; set STOCKVALUATION_INSTALL_DIR to change it. Other commands: ./install.sh status|start|stop|uninstall. The skill file lives at valuation-agent/skills/stockvaluation-io/SKILL.md.
How do you use this skill?
After setup and confirming services are running, ask your Codex or Claude agent: e.g. "Value MSFT using stockvaluation.io". The default is the full researched flow: the agent shows evidence first, pauses for your review, asks guided assumption questions one at a time, and writes the report only after you answer. For prospectus valuations: "Use stockvaluation.io to value a company from this SEC prospectus: <SEC EDGAR HTML URL>". Only explicitly saying quick, no questions, or one-shot report skips the evidence and question loop.
How does this skill compare with similar options?
Compared with asking an LLM to hand-compute a DCF, this project explicitly forbids the agent from calculating valuation numbers itself, delegating deterministic math to a local MCP service. The source material names no specific competing products.