Install
$ agentstack add skill-asgard-ai-platform-skills-algo-rec-hybrid ✓ scanned · ✓ verified, works with Claude Code, Cursor, and more.
Security review
✓ PassedNo issues found. Passed automated security review. · v0.1.0 How review works →
- ✓ Prompt-injection patterns
- ✓ Secret / credential exfiltration
- ✓ Dangerous shell & filesystem operations
- ✓ Untrusted network calls
- ✓ Known-malicious package signatures
What it can access
- ✓ Network access No
- ✓ Filesystem access No
- ✓ Shell / process execution No
- ✓ Environment & secrets No
- ✓ Dynamic code execution No
From automated source analysis of v0.1.0. “Used” means the capability is present in the source — more access means more to trust, not that it’s unsafe.
Verified badge
Passed review? Show it. Paste this badge into your README, it links to the public security report.
Reliability & compatibility
Declared compatibility
Compatibility is declared by the source manifest. End-to-end runtime verification is coming, see below.
We're building live execution health for every listing: tool-call success rate, median latency, uptime, and last-checked timestamps, measured, not self-reported. It isn't live yet, so we don't show numbers we can't stand behind.
How agent discovery & health will work →About
Hybrid Recommendation System
Overview
Hybrid recommendation combines multiple strategies (CF, content-based, knowledge-based) to overcome individual method limitations. Common architectures: weighted, switching, cascade, feature augmentation, and meta-level. Complexity varies by architecture.
When to Use
Trigger conditions:
- Building a production recommendation system that must handle cold start AND personalization
- Single methods have known weaknesses for your use case
- Need to balance accuracy, diversity, and coverage
When NOT to use:
- When you have a single clean data source (start with the matching single method first)
- When system simplicity is more important than marginal accuracy gains
Algorithm
IRON LAW: Hybrid Adds Value ONLY With Complementary Strengths
Combining two systems with the SAME weakness amplifies the weakness.
CF fails on cold start + content-based fails on cold start = hybrid
STILL fails on cold start. Choose components that cover each other's gaps.
Phase 1: Input Validation
Identify available data: interaction history (for CF), item features (for content-based), contextual signals (time, device, location). Map data to method capabilities. Gate: At least two complementary data sources available.
Phase 2: Core Algorithm
Weighted hybrid: Score = α × CFscore + β × CBscore. Tune weights via cross-validation.
Switching hybrid: Use CF when sufficient data exists; switch to content-based for cold start items/users.
Cascade hybrid: First stage filters (e.g., content-based), second stage ranks (e.g., CF) within filtered set.
Feature augmentation: Use one method's output as input features for another (e.g., CF embeddings as content features).
Phase 3: Verification
A/B test hybrid vs individual components. Measure: accuracy (NDCG, precision@K), coverage (% of catalog recommended), diversity (intra-list diversity). Gate: Hybrid outperforms best individual component on primary metric.
Phase 4: Output
Return recommendations with source attribution for explainability.
Output Format
{
"recommendations": [{"item_id": "789", "score": 0.91, "sources": {"cf": 0.85, "content": 0.95}, "method": "weighted"}],
"metadata": {"architecture": "weighted", "weights": {"cf": 0.6, "content": 0.4}, "coverage": 0.78}
}
Examples
Sample I/O
Input: New user with 2 interactions + rich item feature catalog Expected: Switching hybrid: content-based recommendations (insufficient CF data), transitioning to CF as interactions accumulate
Edge Cases
| Input | Expected | Why | |-------|----------|-----| | Completely new user + new item | Fall back to popularity | No data for either method | | Methods disagree strongly | Depends on architecture | Weighted averages; cascade defers to second stage | | One component returns empty | Other component takes over | Graceful degradation |
Gotchas
- Complexity cost: Each added component increases latency, maintenance, and debugging difficulty. Start simple, add complexity only when justified by metrics.
- Weight tuning: Static weights degrade over time. Retune periodically or use learned weights (e.g., a meta-model that predicts which component performs best per context).
- Evaluation is harder: You must evaluate the hybrid AND each component individually to understand contribution and detect regressions.
- Feature leakage: In feature augmentation, ensure the augmenting model's predictions don't leak test-set information during training.
- Diminishing returns: Going from one method to two gives the biggest lift. Adding a third rarely justifies the complexity.
References
- For architecture selection decision guide, see
references/architecture-selection.md - For A/B testing recommendation systems, see
references/ab-testing-recs.md
Source & license
This open-source skill is cataloged on AgentStack and links to its original source — we do not rehost the code.
- Author: asgard-ai-platform
- Source: asgard-ai-platform/skills
- License: MIT
- Homepage: https://github.com/asgard-ai-platform
Install and usage instructions live in the source repository linked above.
Reviews
No reviews yet, be the first.
Write a review
Versions
- v0.1.0 Imported from the upstream source.