{"passport":{"unfragile":{"@version":"1.0","version":"2026-05","artifact":{"id":"github-wanshuiyin--auto-claude-code-research-in-sleep","slug":"wanshuiyin--auto-claude-code-research-in-sleep","name":"Auto-claude-code-research-in-sleep","type":"cli","url":"https://github.com/wanshuiyin/Auto-claude-code-research-in-sleep","page_url":"https://unfragile.ai/wanshuiyin--auto-claude-code-research-in-sleep","categories":["automation"],"tags":["ai-research","ai-tools","aris","autonomous-agent","claude","claude-code","claude-code-skills","codex","deep-learning","gpt","idea-generation","llm","machine-learning","mcp","mcp-server","ml-research","openai","paper-review","paper-writing","research-automation"],"pricing":{"model":"open_source","free":true,"starting_price":null},"status":"active","verified":false},"capabilities":[{"id":"github-wanshuiyin--auto-claude-code-research-in-sleep__cap_0","uri":"capability://planning.reasoning.cross.model.adversarial.review.loop.with.external.llm.verification","name":"cross-model adversarial review loop with external llm verification","description":"Implements a two-model collaboration pattern where Claude Code executes research tasks (code generation, experiment design) while a separate external LLM (GPT-4, Claude, or configurable backend) reviews outputs independently via MCP protocol. The reviewer never sees the executor's reasoning, only final artifacts, forcing fresh evaluation and catching blind spots that single-model self-review misses. State is persisted across review cycles with checkpoint recovery.","intents":["I want Claude to execute experiments but have GPT-4 independently critique the methodology before I run it","I need to prevent my LLM from getting stuck in local minima by forcing adversarial feedback from a different model","I want overnight research runs where the executor and reviewer iterate without human intervention until convergence"],"best_for":["ML researchers automating multi-day research cycles","teams running overnight experiments with cross-model validation","researchers who distrust single-model self-review and want adversarial collaboration"],"limitations":["Requires two separate LLM API keys and incurs 2x inference costs per review cycle","Reviewer latency adds ~30-60s per cycle; not suitable for real-time interactive workflows","Cross-model disagreement resolution requires human intervention or meta-optimizer heuristics","No built-in consensus mechanism if reviewer and executor fundamentally disagree on approach"],"requires":["Claude API key (executor model)","OpenAI API key or alternative LLM endpoint (reviewer model)","MCP server running (Codex MCP for OpenAI, or custom MCP bridge)","Python 3.9+","GPU access for experiment execution (optional but recommended)"],"input_types":["markdown research briefs","code artifacts from executor","experiment results (JSON/CSV)","paper drafts (LaTeX)"],"output_types":["structured review feedback (JSON with scores, critiques, suggestions)","revised code/experiments based on feedback","convergence metrics (review score trends)"],"categories":["planning-reasoning","tool-use-integration","cross-model-collaboration"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-wanshuiyin--auto-claude-code-research-in-sleep__cap_1","uri":"capability://planning.reasoning.autonomous.idea.discovery.and.novelty.validation.against.literature","name":"autonomous idea discovery and novelty validation against literature","description":"Orchestrates a multi-step workflow that generates novel ML research ideas by querying integrated literature sources (Zotero, Obsidian, arXiv, Semantic Scholar) to identify gaps, then validates novelty by cross-referencing recent papers and running lightweight pilot experiments. The system maintains a research wiki that tracks idea genealogy, related work, and experiment outcomes. Novelty scoring combines semantic similarity (embedding-based) and citation analysis.","intents":["I want to generate 10 novel research ideas in an evening and wake up with novelty validation complete","I need to check if my idea already exists in recent literature before investing in full experiments","I want to track idea evolution and see which ideas led to published papers"],"best_for":["PhD students exploring research directions","ML researchers doing rapid idea validation before committing to experiments","teams running continuous research pipelines where ideas feed into experiments"],"limitations":["Novelty detection relies on embedding similarity and citation counts; cannot detect concurrent work submitted to arXiv in the last 48 hours","Pilot experiments are lightweight and may miss subtle failure modes that full-scale experiments would catch","Requires Zotero/Obsidian integration setup; without local literature, falls back to arXiv/Semantic Scholar only","Idea quality depends heavily on initial research brief quality; garbage-in-garbage-out for vague prompts"],"requires":["Zotero library (optional but recommended) or Obsidian vault with paper notes","arXiv API access (free, no key required)","Semantic Scholar API access (free tier available)","Claude Code with file system access to read literature metadata","Python 3.9+ with requests library for API calls"],"input_types":["research brief (markdown with problem statement, constraints, target venue)","literature database (Zotero JSON export or Obsidian markdown files)","prior experiment results (to avoid re-exploring failed directions)"],"output_types":["ranked list of novel ideas (JSON with novelty scores 0-1, related papers, gap analysis)","pilot experiment results (metrics, failure modes)","research wiki entries (idea genealogy, related work, status)"],"categories":["planning-reasoning","search-retrieval","memory-knowledge"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-wanshuiyin--auto-claude-code-research-in-sleep__cap_10","uri":"capability://tool.use.integration.integration.with.external.research.tools.and.data.sources","name":"integration with external research tools and data sources","description":"Provides adapters for popular research tools: Zotero (literature management), Obsidian (note-taking), Feishu/Lark (team notifications), arXiv/Semantic Scholar (paper discovery), and GPU infrastructure (SLURM, Kubernetes). Enables bidirectional sync (e.g., new papers in Zotero trigger idea discovery, paper acceptance triggers Feishu notification). Abstracts tool-specific APIs behind unified interfaces.","intents":["I want new papers in my Zotero library to automatically trigger novelty checks","I need to notify my team on Feishu when a paper is accepted","I want to query arXiv for recent papers in my research area as part of idea discovery"],"best_for":["teams using Zotero, Obsidian, and Feishu for research management","researchers with existing literature databases who want to integrate with ARIS","teams running on shared GPU infrastructure (SLURM, Kubernetes)"],"limitations":["Integration quality depends on tool API stability; breaking changes in tool APIs may break ARIS integration","Bidirectional sync may create conflicts (e.g., if Zotero and ARIS both modify a paper entry)","Tool-specific features (e.g., Zotero tags, Obsidian plugins) may not be fully exposed","Requires API keys or credentials for each tool; credential management is manual","Latency for external tool queries (e.g., arXiv search) may slow down workflows"],"requires":["Tool-specific API keys or credentials (Zotero API key, Feishu webhook, arXiv API access)","Python 3.9+ with tool-specific client libraries (pyzotero, requests, etc.)","Configuration file specifying tool endpoints and credentials","Optional: SLURM or Kubernetes cluster for GPU infrastructure"],"input_types":["tool configuration (API keys, endpoints, sync preferences)","research metadata (ideas, experiments, papers) to sync to external tools"],"output_types":["synced data in external tools (papers in Zotero, notes in Obsidian, notifications in Feishu)","data retrieved from external tools (papers from arXiv, notes from Obsidian)"],"categories":["tool-use-integration","memory-knowledge"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-wanshuiyin--auto-claude-code-research-in-sleep__cap_11","uri":"capability://automation.workflow.interactive.mode.with.human.in.the.loop.checkpoints","name":"interactive mode with human-in-the-loop checkpoints","description":"Supports interactive execution where the system pauses at strategic checkpoints (after idea generation, after experiment results, before paper submission) and waits for human approval/feedback before proceeding. Enables researchers to review intermediate results, make manual adjustments, and guide the system toward desired outcomes. Supports both fully autonomous overnight mode and interactive mode.","intents":["I want to run idea discovery overnight, review results in the morning, and then start experiments","I need to approve experiments before they run on expensive GPU infrastructure","I want to review the paper draft and make edits before the system submits it"],"best_for":["researchers who want oversight over key decisions","teams with expensive GPU infrastructure requiring approval before spending","workflows where human judgment is critical (e.g., deciding which experiments to run)"],"limitations":["Interactive mode requires human availability; not suitable for fully autonomous overnight runs","Checkpoint delays add latency; if researcher doesn't respond for 24 hours, workflow stalls","No built-in escalation mechanism if human doesn't approve within a time window","Feedback format is unstructured; requires clear communication between human and system"],"requires":["Human availability at checkpoints","Web interface or CLI for checkpoint interaction","Python 3.9+ with async support for checkpoint waiting"],"input_types":["intermediate results (ideas, experiments, paper drafts)","human feedback (approval, rejection, modifications)"],"output_types":["checkpoint notifications (email, Slack, web UI)","human-approved results (ideas, experiments, paper drafts)","execution logs showing which checkpoints were approved/rejected"],"categories":["automation-workflow","planning-reasoning"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-wanshuiyin--auto-claude-code-research-in-sleep__cap_2","uri":"capability://automation.workflow.automated.iterative.experiment.execution.with.ablation.and.result.aggregation","name":"automated iterative experiment execution with ablation and result aggregation","description":"Manages end-to-end experiment lifecycle: Claude Code generates experiment code (training loops, hyperparameter sweeps, evaluation scripts), executes them on GPU infrastructure, collects results (metrics, logs, checkpoints), aggregates findings into structured reports, and feeds results back to the reviewer for quality assessment. Supports checkpoint recovery if experiments timeout or fail mid-run. Integrates with GPU resource budgeting to prevent runaway costs.","intents":["I want to run 20 ablation experiments overnight and wake up with aggregated results and statistical significance tests","I need to execute experiments, collect metrics, and automatically generate comparison tables for my paper","I want to recover from mid-run failures without losing progress or re-running completed experiments"],"best_for":["ML researchers running large-scale hyperparameter sweeps","teams with GPU infrastructure (cloud or on-prem) running overnight experiments","researchers who want automated experiment orchestration without manual result collection"],"limitations":["Requires GPU access; CPU-only experiments will be slow and may timeout","No built-in distributed training orchestration; each experiment runs on a single GPU","Result aggregation assumes standard metrics (loss, accuracy, F1); custom metrics require manual integration","Checkpoint recovery works only if experiments write checkpoints to disk; in-memory state is lost","GPU resource budgeting is heuristic-based (estimated cost per experiment); actual costs may vary"],"requires":["GPU infrastructure (NVIDIA CUDA 11.8+ or compatible)","PyTorch or TensorFlow installed","Python 3.9+ with pandas, numpy, matplotlib for result aggregation","Disk space for experiment outputs (checkpoints, logs, results)","Resource budget configuration (max GPU hours, max cost per experiment)"],"input_types":["experiment specification (markdown with hyperparameters, dataset, model architecture)","code templates (PyTorch training loops, evaluation scripts)","dataset references (paths or download URLs)"],"output_types":["experiment results (JSON with metrics, training curves, final checkpoints)","aggregated comparison tables (CSV/LaTeX for paper inclusion)","statistical significance tests (t-tests, confidence intervals)","failure logs and recovery checkpoints"],"categories":["automation-workflow","code-generation-editing","data-processing-analysis"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-wanshuiyin--auto-claude-code-research-in-sleep__cap_3","uri":"capability://code.generation.editing.end.to.end.paper.generation.with.latex.compilation.and.venue.specific.formatting","name":"end-to-end paper generation with latex compilation and venue-specific formatting","description":"Orchestrates paper writing by generating LaTeX source code (sections, figures, tables, citations), compiling to PDF, detecting and fixing compilation errors, and formatting for target venues (NeurIPS, ICML, ICCV, etc.). Integrates experiment results directly into paper (auto-generates figure captions, embeds tables). Maintains LaTeX template library with venue-specific styles. Handles bibliography management via BibTeX.","intents":["I want to generate a complete paper draft from experiment results and have it compile to PDF without errors","I need to reformat my paper for a different venue (e.g., NeurIPS to ICML) without manual LaTeX editing","I want to auto-generate figures and tables from experiment results and embed them in the paper"],"best_for":["ML researchers writing papers from automated experiments","teams submitting to multiple venues and needing rapid reformatting","researchers who want to avoid manual LaTeX debugging"],"limitations":["LaTeX compilation errors require human interpretation for complex cases (e.g., custom packages, macro conflicts)","Figure generation is limited to standard plots (line charts, bar charts, heatmaps); complex visualizations may require manual editing","Bibliography management assumes BibTeX format; other formats (CSL, RIS) require conversion","Venue-specific formatting is template-based; edge cases (unusual page limits, custom sections) may not be handled","No support for collaborative editing or version control integration (e.g., Overleaf)"],"requires":["LaTeX distribution (TeX Live, MiKTeX, or MacTeX)","pdflatex or xelatex compiler","Python 3.9+ with matplotlib, seaborn for figure generation","BibTeX or biber for bibliography processing","Venue-specific LaTeX templates (provided in ARIS or custom)"],"input_types":["paper outline (markdown with sections, subsections)","experiment results (JSON/CSV with metrics, figures)","bibliography (BibTeX file)","venue specification (e.g., 'NeurIPS 2024')"],"output_types":["LaTeX source code (.tex files)","compiled PDF","generated figures (PNG/PDF)","compilation error logs and fixes"],"categories":["code-generation-editing","automation-workflow","text-generation-language"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-wanshuiyin--auto-claude-code-research-in-sleep__cap_4","uri":"capability://text.generation.language.rebuttal.generation.and.reviewer.concern.parsing","name":"rebuttal generation and reviewer concern parsing","description":"Parses reviewer comments (from PDF or text), extracts concerns and questions, maps them to experiment results or paper sections, generates targeted rebuttals, and formats responses according to venue guidelines. Uses semantic matching to link reviewer concerns to relevant experiments or citations. Maintains rebuttal templates for common objection types (novelty, experimental rigor, clarity).","intents":["I want to parse reviewer comments and auto-generate rebuttals that reference my experiments","I need to identify which experiments address which reviewer concerns and structure my response","I want to format rebuttals for a specific venue (e.g., NeurIPS rebuttal format) without manual editing"],"best_for":["researchers managing paper revisions across multiple venues","teams with tight rebuttal deadlines (48-72 hours)","researchers who want to ensure all reviewer concerns are addressed"],"limitations":["Semantic matching between reviewer concerns and experiments is heuristic-based; may miss subtle connections","Rebuttal tone and persuasiveness depend on underlying experiment quality; weak experiments cannot be salvaged by good rebuttals","Venue-specific formatting is template-based; unusual rebuttal requirements may not be handled","Does not handle adversarial reviewers or fundamentally flawed critiques; requires human judgment","PDF parsing may fail on scanned or poorly formatted reviews"],"requires":["Reviewer comments (PDF or text)","Paper source (LaTeX or markdown)","Experiment results (JSON/CSV with metrics)","Rebuttal templates (provided or custom)","Python 3.9+ with pdfplumber or similar for PDF parsing"],"input_types":["reviewer comments (PDF or plain text)","paper source (LaTeX or markdown)","experiment results (JSON/CSV)","venue specification (e.g., 'NeurIPS 2024 rebuttal format')"],"output_types":["parsed concerns (JSON with concern text, severity, category)","rebuttal drafts (markdown or LaTeX)","concern-to-experiment mapping (which experiments address which concerns)","formatted rebuttal document (venue-compliant)"],"categories":["text-generation-language","data-processing-analysis","planning-reasoning"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-wanshuiyin--auto-claude-code-research-in-sleep__cap_5","uri":"capability://memory.knowledge.research.wiki.and.meta.optimization.for.idea.to.paper.tracking","name":"research wiki and meta-optimization for idea-to-paper tracking","description":"Maintains a persistent research wiki (markdown-based) that tracks idea genealogy, related work, experiment outcomes, and paper status. Enables meta-analysis of research productivity (which ideas led to papers, which experiments were most valuable, which venues accept which paper types). Supports automated meta-optimization: analyzing past research cycles to improve future idea generation, experiment selection, and writing strategies.","intents":["I want to track which ideas led to published papers and analyze what made them successful","I need to see the full lineage of an idea from conception to publication","I want to optimize my research process by analyzing which experiment types yield the best papers"],"best_for":["long-term researchers running continuous research pipelines","teams analyzing research productivity and ROI","researchers who want to learn from past cycles to improve future ones"],"limitations":["Meta-optimization is based on historical data; requires at least 5-10 completed research cycles to be meaningful","Causality inference is limited; cannot definitively say which factors led to success vs. correlation","Wiki maintenance requires discipline; incomplete or inaccurate logging reduces meta-analysis value","Venue acceptance is stochastic; meta-optimizer cannot guarantee success for future papers"],"requires":["Markdown-based wiki (local filesystem or Git-backed)","Python 3.9+ with pandas for meta-analysis","Historical research data (at least 5 completed cycles)","Consistent logging of idea, experiment, and paper metadata"],"input_types":["idea specifications (markdown with problem, approach, novelty)","experiment results (JSON/CSV with metrics, runtime, cost)","paper metadata (venue, acceptance status, citation count)","reviewer feedback (structured JSON)"],"output_types":["research wiki (markdown with idea genealogy, related work, outcomes)","meta-analysis reports (which idea types succeed, which experiments are valuable)","optimization recommendations (e.g., 'focus on ideas in domain X, they have 60% acceptance rate')","productivity metrics (ideas-to-papers ratio, time-to-publication, cost per paper)"],"categories":["memory-knowledge","data-processing-analysis","planning-reasoning"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-wanshuiyin--auto-claude-code-research-in-sleep__cap_6","uri":"capability://tool.use.integration.mcp.server.architecture.with.multi.provider.llm.support","name":"mcp server architecture with multi-provider llm support","description":"Implements a Model Context Protocol (MCP) server that abstracts LLM provider differences (OpenAI, Anthropic, Ollama, local models) behind a unified interface. Supports both executor (Claude Code) and reviewer (configurable backend) roles. Handles API key management, rate limiting, token budgeting, and fallback strategies. Enables mix-and-match of models (e.g., Claude executor + GPT-4 reviewer + Ollama local validator).","intents":["I want to use Claude for execution and GPT-4 for review without rewriting code","I need to run experiments with a local Ollama model to avoid API costs","I want to add a third model (e.g., Gemini) as a validator without changing the core system"],"best_for":["researchers with multiple LLM API keys who want to optimize cost/quality","teams running on-prem infrastructure with local models","developers building multi-model research systems"],"limitations":["MCP protocol overhead adds ~50-100ms per request; not suitable for real-time interactive workflows","Model-specific features (e.g., Claude's extended thinking, GPT-4's vision) may not be fully exposed through the abstraction","Rate limiting is per-provider; coordinating limits across multiple providers requires manual tuning","Token budgeting is approximate; actual token counts may vary by model and encoding","Fallback strategies (e.g., retry on rate limit) may cause unexpected delays"],"requires":["MCP server implementation (provided in ARIS or custom)","API keys for executor and reviewer models","Python 3.9+ with httpx or similar for async HTTP","Configuration file specifying model endpoints and credentials","Optional: Ollama running locally for local model support"],"input_types":["model configuration (JSON with provider, endpoint, credentials)","prompts (text or structured messages)","token budget constraints (max tokens per request, per cycle)"],"output_types":["unified LLM responses (text, structured JSON)","token usage metrics (input, output, total)","rate limit status and retry information"],"categories":["tool-use-integration","automation-workflow"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-wanshuiyin--auto-claude-code-research-in-sleep__cap_7","uri":"capability://automation.workflow.state.persistence.and.checkpoint.recovery.for.long.running.workflows","name":"state persistence and checkpoint recovery for long-running workflows","description":"Implements a state management system that persists workflow state (current idea, experiment progress, paper draft, rebuttal status) to disk at regular intervals. Enables recovery from failures (network outages, GPU crashes, API rate limits) by resuming from the last checkpoint rather than restarting from scratch. Tracks state transitions and enables rollback to previous states if needed.","intents":["I want to run a 12-hour research cycle and recover gracefully if my GPU crashes after 8 hours","I need to pause an experiment, make manual changes, and resume from where I left off","I want to rollback to a previous state if the reviewer rejects the current direction"],"best_for":["researchers running long-running overnight experiments","teams with unreliable infrastructure (cloud spot instances, shared GPU clusters)","workflows requiring manual intervention at checkpoints"],"limitations":["Checkpoint size grows with experiment count; large workflows may consume significant disk space","Recovery is not atomic; partial state corruption may require manual intervention","Rollback to previous states may invalidate downstream results (e.g., if you rollback an experiment, the paper draft becomes stale)","State persistence adds ~5-10% overhead to total runtime","No distributed state management; only works on single machine"],"requires":["Local filesystem with sufficient disk space (10GB+ for large workflows)","Python 3.9+ with pickle or JSON for serialization","Consistent checkpoint naming and versioning scheme","Manual monitoring for state corruption"],"input_types":["workflow state (ideas, experiments, paper drafts, rebuttal status)","checkpoint metadata (timestamp, workflow stage, model versions)"],"output_types":["checkpoint files (JSON or pickle format)","recovery logs (which checkpoints were used, when)","state transition history (for rollback analysis)"],"categories":["automation-workflow","memory-knowledge"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-wanshuiyin--auto-claude-code-research-in-sleep__cap_8","uri":"capability://automation.workflow.skill.based.workflow.composition.with.markdown.only.definitions","name":"skill-based workflow composition with markdown-only definitions","description":"Organizes research capabilities as discrete, composable 'skills' defined in markdown files (no code framework required). Each skill specifies inputs, outputs, dependencies, and execution logic. Skills are composed into workflows (idea discovery → experiment → paper writing → rebuttal) using a simple orchestration language. Enables non-technical researchers to customize workflows by editing markdown without touching code.","intents":["I want to customize the research workflow by adding a new skill (e.g., custom experiment type) without modifying the core system","I need to compose skills in a different order (e.g., paper writing before experiments) for a specific research project","I want to share my custom skills with collaborators as markdown files"],"best_for":["non-technical researchers who want to customize workflows","teams sharing research methodologies across projects","researchers building domain-specific research pipelines"],"limitations":["Markdown-based skill definitions lack type safety; runtime errors may occur if skill inputs/outputs don't match","No built-in skill versioning; managing skill dependencies across projects is manual","Skill composition is sequential; no built-in support for parallel or conditional execution","Debugging skill failures requires reading markdown and logs; no visual workflow editor","Performance optimization is limited; no skill-level caching or memoization"],"requires":["Markdown editor (any text editor)","Python 3.9+ for skill execution","Skill template library (provided in ARIS)","Understanding of skill input/output format (JSON schema)"],"input_types":["skill definitions (markdown with inputs, outputs, dependencies, logic)","workflow composition (markdown listing skill sequence)"],"output_types":["executed skills (outputs as JSON/CSV/markdown)","workflow execution logs (which skills ran, in what order, with what results)"],"categories":["automation-workflow","code-generation-editing"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-wanshuiyin--auto-claude-code-research-in-sleep__cap_9","uri":"capability://data.processing.analysis.resource.budgeting.and.cost.optimization.for.gpu.experiments","name":"resource budgeting and cost optimization for gpu experiments","description":"Tracks GPU hours, API costs, and compute budgets across experiments. Estimates experiment cost before execution (based on model size, dataset, hyperparameters) and prevents runaway spending. Supports cost-aware experiment selection (e.g., 'run only experiments under $10'). Provides cost-per-paper metrics and recommendations for cost optimization (e.g., 'use smaller model for ablations').","intents":["I want to run 50 experiments but only have a $500 budget; help me select which ones to run","I need to estimate the cost of an experiment before running it","I want to see how much each paper cost to produce and optimize future research"],"best_for":["researchers with limited compute budgets","teams managing shared GPU infrastructure with cost allocation","researchers optimizing research ROI (cost per paper)"],"limitations":["Cost estimation is heuristic-based; actual costs may vary by 20-50% due to GPU utilization, data loading, etc.","Does not account for human time (researcher effort); only tracks compute costs","Cost-aware experiment selection is greedy; may not find globally optimal subset","No support for cost-sharing across projects or teams","GPU pricing varies by provider and region; requires manual configuration"],"requires":["GPU pricing configuration (per-hour rates for each GPU type)","Experiment specifications with estimated runtime and model size","Python 3.9+ with pandas for cost analysis","Budget constraints (total budget, per-experiment limits)"],"input_types":["experiment specifications (model size, dataset, hyperparameters, estimated runtime)","GPU pricing (per-hour rates)","budget constraints (total, per-experiment)"],"output_types":["cost estimates (per experiment, total)","cost-optimized experiment selection (which experiments to run within budget)","cost analysis reports (cost per paper, cost per metric improvement)","optimization recommendations"],"categories":["data-processing-analysis","planning-reasoning"],"confidence":0.5,"matches":0,"success_rate":0}],"trust":{"score":50,"verified":false,"data_access_risk":"high","permissions":["Claude API key (executor model)","OpenAI API key or alternative LLM endpoint (reviewer model)","MCP server running (Codex MCP for OpenAI, or custom MCP bridge)","Python 3.9+","GPU access for experiment execution (optional but recommended)","Zotero library (optional but recommended) or Obsidian vault with paper notes","arXiv API access (free, no key required)","Semantic Scholar API access (free tier available)","Claude Code with file system access to read literature metadata","Python 3.9+ with requests library for API calls"],"failure_modes":["Requires two separate LLM API keys and incurs 2x inference costs per review cycle","Reviewer latency adds ~30-60s per cycle; not suitable for real-time interactive workflows","Cross-model disagreement resolution requires human intervention or meta-optimizer heuristics","No built-in consensus mechanism if reviewer and executor fundamentally disagree on approach","Novelty detection relies on embedding similarity and citation counts; cannot detect concurrent work submitted to arXiv in the last 48 hours","Pilot experiments are lightweight and may miss subtle failure modes that full-scale experiments would catch","Requires Zotero/Obsidian integration setup; without local literature, falls back to arXiv/Semantic Scholar only","Idea quality depends heavily on initial research brief quality; garbage-in-garbage-out for vague prompts","Integration quality depends on tool API stability; breaking changes in tool APIs may break ARIS integration","Bidirectional sync may create conflicts (e.g., if Zotero and ARIS both modify a paper entry)","builder identity is not verified yet","no observed match outcomes yet"],"rank_breakdown":{"adoption":0.6349772337466797,"quality":0.49,"ecosystem":0.6000000000000001,"match_graph":0.25,"freshness":0.75,"weights":{"adoption":0.25,"quality":0.25,"ecosystem":0.1,"match_graph":0.28,"freshness":0.12}},"observed_outcomes":{"matches":0,"success_rate":0,"avg_confidence":0,"top_intents":[],"last_matched_at":null},"maintenance":{"status":"active","updated_at":"2026-05-24T12:16:22.064Z","last_scraped_at":"2026-05-03T13:56:56.344Z","last_commit":"2026-05-03T11:59:10Z"},"community":{"stars":7959,"forks":742,"weekly_downloads":null,"model_downloads":null,"model_likes":null}},"distribution":{"claim_url":"https://unfragile.ai/submit?claim=wanshuiyin--auto-claude-code-research-in-sleep","compare_url":"https://unfragile.ai/compare?artifact=wanshuiyin--auto-claude-code-research-in-sleep"}},"signature":"lXyL/lmthCaxR+FPOiOOHUH4+zEH+mJjTiIdgKmjUdkKBthD2OJymPuULJ6rgfITQZKdk2qCdw2YBKjhalr9Ag==","signedAt":"2026-06-20T08:36:26.566Z","signedBy":"unfragile.ai","version":1},"_links":{"self":"https://unfragile.ai/api/v1/passport/wanshuiyin--auto-claude-code-research-in-sleep","artifact":"https://unfragile.ai/wanshuiyin--auto-claude-code-research-in-sleep","verify":"https://unfragile.ai/api/v1/verify?slug=wanshuiyin--auto-claude-code-research-in-sleep","publicKey":"https://unfragile.ai/api/v1/trust-passport-public-key","spec":"https://unfragile.ai/trust","schema":"https://unfragile.ai/schema.json","docs":"https://unfragile.ai/docs"}}