Massive, well-tested Python monorepo where thorough docs and modern tooling overcome heavy context strain.
last scored 2026-09-19 · both lenses
Readiness lenses
The same repo, two ways: how ready it is for an AI coding agent, and for a human newcomer. Switch lenses to see each one's score and checks.
How ready the repo is for an AI coding agent to read, build, and operate it.
78 / 10024 of 39 checks passed across 6 categories.
Machine Orientation
89Comprehensive agent instructions and monorepo documentation make working in this repo seamless for an AI.
The repository provides exceptional machine orientation with dedicated AGENTS.md and CLAUDE.md files detailing the monorepo architecture, development tools (uv, make), test execution, and commit conventions. It clearly clears the Solid to Exemplary range (89 score), backed by explicit setup instructions, a devcontainer, and comprehensive build/test commands.
Reproducible Setup
80Solid setup using uv and devcontainers, though root orchestration could be more unified.
The repository features `uv.lock` and `.devcontainer/` files along with rich onboarding guidance in `CLAUDE.md`, but lacks root-level build or test scripts and leaves some dependency configuration decentralized across packages. This places it solidly in the 70–89 Solid band, where setup is mostly reproducible via `uv` and devcontainer tools but lacks single-command root orchestration.
Code Navigability
65Solid modular separation in a large monorepo, with clear architectural docs that guide navigation.
The repository is well-organized into distinct packages under libs/ (such as libs/core/ and libs/partners/) with clear module boundaries and architecture documents like CLAUDE.md. However, due to its massive scale (over 3100 files) and non-conventional layout in terms of top-level source folders, locating specific integration code requires careful navigation through packages. This lands solidly in the Workable band.
Verification Surface
85Extensive test suites and thorough CI workflows provide strong verification coverage, though local agent discovery of commands could be more unified.
The repository features extensive test suites and comprehensive GitHub Actions CI workflows (28 workflow files) that provide robust verification capability, clearing the solid band. However, the lack of a top-level Makefile or unified runner scripts for local agent execution leaves minor gaps in agent discoverability of verification commands.
Agent Safety
85Solid agent safety hygiene with strong secret protection, missing only a security disclosure policy.
The repository demonstrates solid agent safety with env.example present, .gitignore covering sensitive files, no committed secrets, and a dependency update tool (.github/dependabot.yml). However, it lacks a SECURITY.md file to declare vulnerability reporting guidelines, placing it firmly in the Solid band.
Context Economy
60Massive repository scale strains agent context windows without concise navigation aids or explicit exclusion markers.
With 3163 files and lacking modular bundling, LLMs navigating the repository face a heavy context load, though node modules and build outputs are correctly excluded. The lack of structured guidance or linguist markers for generated content means agents must parse raw source bulk blindly. Falling into the Workable band, signal-to-noise ratio suffers from sheer breadth without concise navigation aids.
Machine Orientation
6 checks passed4 problems found
- lowAgent instructions stay lean
A bloated instructions file burns context and measurably hurts more than it helps.
Fix: Trim AGENTS.md to the load-bearing commands and conventions; link out to the rest.
- lowllms.txt present
An llms.txt is the emerging machine-orientation standard — a curated map for LLMs.
Fix: Add an llms.txt pointing at the key docs and entry points.
- lowExamples directory
An examples/ directory gives an agent runnable, copyable references for the API.
Fix: Add an examples/ directory with small, runnable usage samples.
- lowContribution conventions are written down
A contributor guide is where an agent learns the branch, commit, and review conventions it must follow.
Fix: Add a CONTRIBUTING.md stating the branch naming, commit format, and how a change gets reviewed.
- README present — An agent reconstructs what the repo is and how to work in it from the README first.
- Agent instructions file — AGENTS.md / CLAUDE.md is the direct, machine-read channel for entry points and conventions.
- Repository description set — The one-line description is the fastest orientation signal an agent reads.
- Topics set — GitHub topics situate the repo's domain and stack for an agent at a glance.
- Architecture doc — An ARCHITECTURE doc hands an agent the module map instead of making it infer one.
- README shows usage — A usage/example section tells an agent how the project is actually invoked.
Reproducible Setup
5 checks passed1 problem found
- mediumRuntime / toolchain pinned
An unpinned runtime makes an agent guess the version a clean environment needs.
Fix: Pin the runtime with .nvmrc / .tool-versions / an engines field / packageManager.
- Lockfile committed — Without a lockfile two clones can resolve different dependency trees — the build isn't reproducible.
- Env template present — A .env.example tells an agent which configuration keys it must supply to run.
- Container or dev-container — A Dockerfile / compose / devcontainer removes 'works on my machine' from setup.
- Dev container — A .devcontainer gives an agent a one-command, fully-declared environment.
- README documents setup — Explicit install/setup steps are what let an agent go from clone to running.
Code Navigability
1 check passed3 problems found
- mediumConventional source layout
A recognised src/ · lib/ · app/ layout lets an agent localise code without spelunking.
Fix: Group source under a conventional top-level directory (src/, lib/, app/, …).
- lowFormatter configured
A formatter config (Prettier/Biome/rustfmt/…) keeps style uniform across the tree.
Fix: Add a formatter (Prettier, Biome, rustfmt, …) and commit its config.
- lowTyped public API
A declared `types` entry gives an agent typed signatures to anchor an edit on.
Fix: Ship type declarations and point package.json `types`/`typings` at them.
- .editorconfig present — An .editorconfig keeps whitespace and encoding consistent, so diffs stay legible.
Verification Surface
3 checks passed4 problems found
- mediumTest command defined
A `test` script is the documented, discoverable way to run the suite.
Fix: Add a `test` script (package.json / Makefile / Taskfile) that runs the suite.
- lowLint command defined
A linter an agent can run catches a class of mistakes before they ship.
Fix: Add a `lint` script and a linter config.
- lowTypecheck command
A typecheck script lets an agent catch type errors before they ship.
Fix: Add a `typecheck` script (e.g. `tsc --noEmit`).
- lowBuild command
A documented build command is the discoverable way for an agent to produce artifacts.
Fix: Add a `build` script that produces the distributable.
- Tests present — Runnable tests are the ground truth an agent checks its own edits against.
- CI configured — Readable CI is the feedback loop an agent reads to know what 'green' means here.
- Task runner present — A Makefile / Taskfile / justfile gives an agent a single index of the project's commands.
Agent Safety
7 checks passed1 problem found
- mediumSecurity policy
A SECURITY.md is where an autonomous security agent reads this repo's rules before acting on it.
Fix: Add a SECURITY.md stating the disclosure channel and the repo's security rules.
- No committed .env — A tracked real .env hands secrets to anything — including an agent — that reads the repo.
- No exposed secrets — Secret-shaped literals in tracked files are a live credential leak.
- .gitignore covers env files — An ignore rule for .env is what keeps the next careless commit from leaking secrets.
- CODEOWNERS present — CODEOWNERS marks the 'don't touch without review' zones an agent should respect.
- Automated dependency updates — Dependabot / Renovate keeps dependencies patched without a human in the loop.
- .gitignore present — A .gitignore is the first guard against an agent committing secrets or build junk.
- License makes the code reusable — Without a license an agent cannot safely copy, redistribute, or vendor any of this code.
Context Economy
2 checks passed2 problems found
- lowGenerated / vendored files marked
A .gitattributes linguist marker tells tools (and agents) what to skip.
Fix: Mark generated/vendored paths in .gitattributes (linguist-generated / linguist-vendored).
- lowNo oversized source file
A single file in the hundreds of KB blows past an agent's effective context window.
Fix: Split the largest files along their natural seams.
- Dependencies not vendored in — A committed node_modules / vendor tree drowns the real signal an agent needs.
- Build output not committed — Generated dist/ · build/ output is noise an agent has to read past.
How ready the repo is for a human newcomer to understand, set up, and contribute.
79 / 10021 of 32 checks passed across 6 categories.
First Impression
85Clear, comprehensive first impression with instant quickstart and ecosystem context.
The repository clears the Solid band for First Impression: the README clearly explains the project's purpose as an agent engineering platform, provides an immediate uv-based quickstart with a functional Python code snippet, and outlines the broader ecosystem. While env.example was listed as present in metadata, the primary README contents are clean and exceptionally well-structured for immediate newcomer orientation.
Getting Running
80Solid developer setup driven by uv and documented clearly in CLAUDE.md, with minor directory layout friction.
The repository features a UV lockfile, a docker-compose setup, and comprehensive development instructions in CLAUDE.md, earning a Solid rating. Minor gaps exist because top-level make commands referenced in the docs are nested in subdirectories rather than present at root.
Finding Your Way
85Clear architectural guides in AGENTS.md make navigation straightforward despite the deep monorepo structure.
Solid (70–89 band) — the repository provides an exceptional AGENTS.md architecture document detailing the monorepo structure, development tasks, and module boundaries, though traditional conventionalLayout=no applies to its nested package structure. An agent can easily build a mental map using the explicit package directory layout and AGENTS.md guides.
Path to Contribute
65External documentation links replace a local contribution guide, creating onboarding friction.
The repository lacks a local CONTRIBUTING.md file (relying instead on external documentation links) and has no local development setup guide within the repo itself, landing it in the Workable band. While issue and PR templates exist, the absence of an on-repo contribution guide creates friction for new contributors looking for explicit dev setup and testing instructions.
Signs of Life
95Extremely active project with robust CI and frequent commits, fully demonstrating sustained maintenance.
The repository shows exceptional signs of life with recent commits (pushed September 2026), an extensive set of CI workflows (28 workflow files including automated tests, linting, releases, and dependency bumping), and active tooling like dependabot. This clearly clears the Exemplary band (90-100) for activity and maintenance sustainability.
Open Door
65Solid open-source posture with an MIT license and templates, though lacking a local code of conduct file.
The repository provides a clear MIT license and issue templates, but lacks a Code of Conduct and a dedicated CONTRIBUTING.md file (though the README references external documentation for contributing). Based on these signals, the project clears the Workable band (50–69).
First Impression
5 checks passed1 problem found
- lowExamples to learn from
An examples/ directory gives a newcomer something concrete to run and adapt.
Fix: Add an examples/ directory with small, runnable samples.
- README present — The README is the first screen — with none, a newcomer has nothing to land on.
- Repository description set — The one-line description sets expectations before a newcomer even opens the README.
- Topics set — Topics situate the project's domain at a glance and help a newcomer find it.
- Status badges — Build/version badges signal at a glance that the project is alive and healthy.
- README shows what it does — A usage/example section lets a newcomer see the tool in action before committing.
Getting Running
5 checks passed1 problem found
- mediumPrerequisite versions pinned
Unpinned prerequisites are the classic 'works on my machine' first-run failure.
Fix: Pin the required versions with .nvmrc / .tool-versions / an engines field.
- Lockfile committed — Without a lockfile a newcomer's install resolves differently and hits errors the docs don't mention.
- Env template present — A .env.example shows a newcomer exactly which settings they must fill in to run it.
- One-command environment — A Dockerfile / compose / devcontainer turns a fiddly setup into one command.
- README documents setup — Explicit install steps are the difference between a 5-minute start and giving up.
- One-click dev container — A .devcontainer lets a newcomer start in a cloud IDE with zero local setup.
Finding Your Way
2 checks passed3 problems found
- mediumConventional source layout
A familiar src/ · lib/ · app/ layout lets a newcomer guess where things live.
Fix: Group source under a conventional top-level directory (src/, lib/, app/, …).
- lowNo oversized source file
A single thousand-line file is a wall a newcomer bounces off.
Fix: Split the largest files along their natural seams.
- lowFormatter configured
An auto-formatter means a newcomer never guesses the house style.
Fix: Add a formatter (Prettier, Biome, rustfmt, …) and commit its config.
- Architecture / overview doc — An overview hands a newcomer the map instead of making them reconstruct it.
- .editorconfig present — Consistent indentation/encoding keeps the code readable and diffs clean for newcomers.
Path to Contribute
3 checks passed3 problems found
- mediumCONTRIBUTING guide
A CONTRIBUTING guide is the difference between a guessed and a guided first PR.
Fix: Add a CONTRIBUTING.md covering dev setup, the test command, and how to submit a change.
- lowTest command defined
A documented test command lets a contributor check their change before opening a PR.
Fix: Add a `test` script that runs the suite.
- lowLint command
A linter lets a first-time contributor catch style issues before review.
Fix: Add a `lint` script and a linter config.
- Issue templates — Issue templates show a newcomer how to file something useful — and that contributions are welcome.
- Pull-request template — A PR template tells a first-time contributor what a good change includes.
- Task runner — A Makefile / Taskfile gives a contributor a single index of the project's commands.
Signs of Life
4 checks passed1 problem found
- lowFunding configured
A FUNDING config signals an invested, sponsored project — not a one-off dump.
Fix: Add a .github/FUNDING.yml if the project accepts sponsorship.
- Tests present — A test suite signals a project that's cared for, not abandoned.
- CI configured — Green CI on every change tells a newcomer the project is actively kept working.
- Automated dependency updates — Dependabot / Renovate activity is a visible heartbeat of ongoing maintenance.
- Changelog — A maintained CHANGELOG shows a newcomer the project ships and records its changes.
Open Door
2 checks passed2 problems found
- lowCode of conduct
A code of conduct states the social ground rules that make it safe to step in.
Fix: Add a CODE_OF_CONDUCT.md (the Contributor Covenant is the de-facto standard).
- lowSecurity policy
A SECURITY.md tells a newcomer how to report a problem responsibly.
Fix: Add a SECURITY.md describing how to report a vulnerability.
- License present — With no license the project isn't legally reusable — the door is shut however friendly the README.
- License is a standard one — A non-standard or custom license is a legal question mark a newcomer won't resolve.
Where the grip slips
- lowCode Navigability+6 pts if fixed
Monorepo scale and package fragmentation require precise path navigation
The codebase spans thousands of files across multiple independent library packages in a monorepo structure, which can occasionally make file localization non-obvious for agents without clear package-level path hints.
Fix: Maintain and update concise package map docs within individual subdirectories in libs/ to accelerate path resolution.
- mediumContext Economy+4 pts if fixed
High volume of unindexed files
Repository contains over 3000 files without structured context boundaries or code maps for agents.
Fix: Add a concise directory index or map specifically for agents under docs/ or an explicit AGENTS.md guide.
- mediumReproducible Setup+4 pts if fixed
Missing root-level build and test task orchestration
Dependency and test invocation requires navigating package directories or using `uv` across multiple sub-libraries because root-level Makefiles or setup scripts are absent.
Fix: Add a root-level Makefile or task runner script that unifies workspace setup and test execution.
- lowVerification Surface+3 pts if fixed
Missing unified local test/lint runner scripts
No unified top-level test or lint runner script is exposed for local agent usage, requiring manual discovery of sub-package test commands across multiple directories.
Fix: Add a top-level Makefile or task runner configuration (like Taskfile.yaml) exposing standard commands for testing and linting across all sub-libraries.
- lowAgent Safety+2 pts if fixed
Missing SECURITY.md vulnerability policy
The repository lacks a SECURITY.md file for vulnerability disclosure instructions.
Fix: Add a SECURITY.md file at the repository root detailing vulnerability reporting policies.
- lowMachine Orientation+1 pts if fixed
Duplicated agent guideline files
AGENTS.md and CLAUDE.md are identical and duplicated, which creates maintenance overhead.
Fix: Consolidate into a single source of truth or symlink CLAUDE.md to AGENTS.md.
Show your score
[](https://latch.fyi/langchain-ai/langchain)Share this analysis
https://latch.fyi/langchain-ai/langchainFixed some issues? Re-analyze to measure your progress →
Copy the whole report
Grab the entire verdict in one go — a Markdown block for a README or an issue, plain text, or a prompt you can paste straight into an LLM.