Are there any CI/CD tools that natively handle monorepo caching well?

I'm currently in the planning phase for a significant CI/CD migration, driven primarily by our organization's expansion into a large-scale monorepo structure. Our current platform's caching mechanisms are proving to be a significant bottleneck, both in terms of cost and build time. The primary pain point is the granularity and intelligence of dependency caching, particularly for partial builds.

I am looking for tools that offer **native, first-class support for monorepo caching patterns**. By "native," I mean the tool should understand the monorepo's structure and can automatically:
* Compute a dependency graph (e.g., from `package.json`, `go.mod`, `BUILD` files) to determine which services/packages are affected by a given change.
* Cache intermediate build artifacts (e.g., `node_modules` for specific workspaces, compiled binaries) at a sub-repo level, not just the entire repository.
* Share these fine-grained caches efficiently across pipelines and branches, invalidating only the necessary parts.

I have begun a comparative analysis, but vendor documentation often emphasizes generic caching rather than monorepo-specific logic. I am particularly interested in real-world implementation details. For example:

| Cache Strategy | Our Current Tool's Approach | Desired Native Behavior |
| ----------------------- | ------------------------------------ | --------------------------------------------------------------------------------------- |
| **Dependency Restoration** | Caches the entire root `node_modules`. | Caches `node_modules` per workspace, using a lockfile hash as the cache key. |
| **Affected Projects** | Requires custom scripting to compute. | Provides CLI or built-in commands to output changed projects (e.g., `nx affected` integration). |
| **Build Artifact Reuse** | Manual upload/download of artifacts. | Automatic promotion and reuse of trusted artifacts from upstream/main branch builds. |

My core questions are:

1. Which CI/CD platforms have you found to have genuinely robust, out-of-the-box features for monorepos? I'm evaluating solutions like Buildkite with its agent model, CircleCI with their dynamic config and orbs, and GitHub Actions with its caching API, but I'm unsure how much heavy lifting requires custom code.
2. How do these tools handle the "dependency graph" problem? Do they rely on external tools (Nx, Turborepo, Lerna) for computation, or do they offer their own primitives?
3. What has been your experience with cache performance and integrity, especially when dealing with hybrid monorepos containing multiple languages and build systems?

I intend to prototype a few options, and I will be measuring success through specific metrics: mean build time for a marginal change, cache hit rate, and pipeline configuration complexity (lines of YAML/script). Any detailed accounts of migration pain points, particularly around cache key design and secrets management for monorepo pipelines, would be invaluable.

— Amanda