My-Jogyo: The Secret Research Lab Top AI Engineers Won't Share

My-Jogyo: The Secret Research Lab Top AI Engineers Won't Share

What if you could hand your most tedious research tasks to a team of tireless PhD-level assistants—and actually trust the results? Not a fantasy. Not a $50,000 consulting contract. A free, open-source multi-agent system that transforms scattered ideas into publication-ready notebooks while you grab coffee.

Here's the painful truth every data scientist knows: 80% of research time dies in the gap between "what if" and "what works." You sketch a hypothesis. You write boilerplate. You debug pandas merges. You forget to save a critical visualization. Three hours later, you're not closer to insight—you're closer to burnout. Meanwhile, your competitors at top AI labs seem to ship reproducible studies weekly. Their secret? They stopped doing research manually.

Enter My-Jogyo—the multi-agent research automation system that turns OpenCode into your personal scientific laboratory. Named after the Korean academic tradition where professors (Gyoshu) guide and teaching assistants (Jogyo) execute, this tool doesn't just generate code. It orchestrates an entire research workflow: hypothesis formation, adversarial verification, statistical validation, and narrative report generation. Every experiment becomes a reproducible .ipynb. Every claim faces a skeptical PhD reviewer before acceptance. And yes, you can literally walk away while it works.

Stop drowning in notebook chaos. Start shipping verified research. Let's expose how My-Jogyo actually works—and why the developers who discover it first are building an unfair advantage.

What is My-Jogyo?

My-Jogyo is an end-to-end research automation framework created by Yeachan Heo that integrates with OpenCode and Claude Code via the Model Context Protocol (MCP). Born from the frustration of watching brilliant researchers waste cycles on mechanical tasks, it implements a multi-agent architecture where specialized AI agents collaborate like a real university research lab.

The project's Korean naming isn't decorative—it's architectural philosophy. Gyoshu (교수, Professor) serves as the orchestrator agent that plans research direction, manages sessions, and enforces quality standards. Jogyo (조교, Teaching Assistant) functions as the execution engine, running Python^{↗ Bright Coding Blog} code through a persistent REPL that preserves variables across sessions. Supporting them are Baksa (박사, PhD Reviewer)—an adversarial verifier that challenges every statistical claim—and the Jogyo Paper Writer, which transforms raw markers into polished research narratives.

Why is My-Jogyo trending now? Three forces converged:

• The reproducibility crisis in ML research has made structured, verifiable workflows essential
• OpenCode's plugin ecosystem matured enough to support sophisticated agent orchestration
• MCP standardization finally lets AI assistants securely execute code with persistent state

Unlike generic code generation tools, My-Jogyo enforces rigorous statistical discipline. Its "Two-Gate Completion" system requires both evidence quality (Trust Gate) and goal achievement (Goal Gate) before marking research complete. This isn't automation for automation's sake—it's automation that makes your work more credible, not less.

The repository has gained rapid traction among researchers who previously cobbled together Jupyter templates, manual logging, and prayer. With seamless .ipynb and REPL integration, it bridges the gap between exploratory hacking and production-grade reproducibility.

Key Features That Separate My-Jogyo From Toy Tools

My-Jogyo isn't another ChatGPT wrapper that dumps untested code into your lap. Its feature set reflects hard-won lessons from actual research workflows:

🔬 Hypothesis-Driven Research Markers The system structures all output through semantic markers: [OBJECTIVE], [HYPOTHESIS], [FINDING], [CONCLUSION]. This isn't bureaucratic overhead—it's machine-readable provenance that enables automated verification and report generation. Your research becomes queryable, auditable, and self-documenting.

🐍 Persistent Python REPL Unlike ephemeral code execution, My-Jogyo's REPL maintains variable state across sessions. Load a 2GB dataset once. Transform it across ten research questions. The kernel survives, just like a real Jupyter environment. No more re-running expensive preprocessing because your context window expired.

📓 Auto-Generated Notebooks Every experiment automatically produces a reproducible .ipynb file in your project's notebooks/ directory. These aren't afterthought exports—they're the source of truth, capturing code, outputs, markers, and metadata. Share them. Version them. Reproduce them six months later.

🤖 Autonomous Mode (/gyoshu-auto) Set a research goal and disengage. The Professor agent plans, the TA executes, the PhD reviewer verifies, and the Paper Writer documents. Return to a complete research package. This isn't hype—it's structured delegation with quality gates preventing garbage-in-garbage-out.

🔍 Adversarial Verification (Baksa Agent) Every [FINDING] faces automatic challenge. No confidence interval? Downgraded to "Exploratory." No effect size? Trust score plummets. This institutionalizes the skeptical colleague every good researcher needs but few can afford.

🎯 Two-Gate Completion System

• Trust Gate: Statistical evidence must meet thresholds (CI, effect size, baseline comparison)
• Goal Gate: The original research objective must be demonstrably achieved Both must pass for SUCCESS status. No more "we ran models" without "we answered the question."

📝 AI-Powered Report Generation Raw markers transform into narrative prose: "Our analysis of 1,599 wine samples revealed that alcohol content emerges as the dominant predictor of quality ratings (r = 0.47)..." The Paper Writer agent handles the tedious conversion from structured data to readable science.

🔄 Session Management Research is rarely linear. Branch experiments, replay sessions, continue interrupted work. My-Jogyo treats research as a versioned, navigable graph—not a fragile linear notebook.

Use Cases: Where My-Jogyo Actually Shines

1. Exploratory Data Analysis at Scale

Financial analysts at crypto trading firms need rapid, defensible EDA. My-Jogyo's Binance Futures example demonstrates 3D volume-price-time analysis, correlation heatmaps with dendrograms, and volatility surfaces—all automatically structured with markers and exported to reproducible notebooks. The PhD reviewer catches spurious correlations before they become expensive trading signals.

2. Academic Research Reproducibility

Graduate students face brutal reproducibility requirements. My-Jogyo enforces them automatically: every statistical claim carries confidence intervals and effect sizes, every ML result includes cross-validation scores and baseline comparisons. Reviewers get clean, verifiable artifacts instead of messy .py files and forgotten parameters.

3. Enterprise ML Pipeline Documentation

Data science teams in regulated industries (healthcare, finance) need audit trails. My-Jogyo's marker system creates them implicitly. The [DATA], [METRIC:*], [LIMITATION] tags build compliance-ready documentation without additional overhead. Autonomous mode lets senior researchers delegate standard analyses while maintaining oversight through trust scores.

4. Teaching and Mentorship

Instructors can set research goals and let students observe the structured reasoning process. The Professor-TA-Reviewer dynamic models scientific methodology explicitly. Students see why claims require evidence, not just that they do. The auto-generated reports provide immediate feedback on writing quality.

5. Rapid Prototyping for Kaggle Competitions

Competition participants need fast iteration with rigorous validation. My-Jogyo's persistent REPL eliminates reprocessing overhead. The adversarial verifier prevents leaderboard overfitting by demanding cross-validation evidence. Autonomous mode runs overnight experiments while competitors sleep.

Step-by-Step Installation & Setup Guide

My-Jogyo offers three installation paths depending on your workflow. Here's how to get running in under five minutes.

Option 1: Claude Code via MCP (Recommended for Claude Users)

The Model Context Protocol provides the deepest integration:

# Clone and build the MCP server
git clone https://github.com/Yeachan-Heo/My-Jogyo.git
cd My-Jogyo/src/mcp
npm install && npm run build

# Register with Claude Code
claude mcp add gyoshu-mcp "$(pwd)/build/index.cjs"

Verify the connection:

claude mcp list
# Expected output: gyoshu-mcp: ✓ Connected

This exposes 12 research tools including python_repl, research_manager, gyoshu_snapshot, checkpoint_manager, notebook_writer, and notebook_search.

Option 2: OpenCode Plugin (Simplest)

Add to your opencode.json:

{
  "plugin": ["gyoshu"]
}

OpenCode auto-installs from npm on next startup. No manual dependency management.

Option 3: CLI Installer (Most Flexible)

# Zero-install execution with bunx
bunx gyoshu install

# Or install globally for repeated use
npm install -g gyoshu
gyoshu install

The CLI automatically modifies your opencode.json and verifies the installation.

Environment Setup

My-Jogyo requires Python 3.10+ and prefers your project's virtual environment:

# Create isolated environment
python3 -m venv .venv

# Install core data science stack
.venv/bin/pip install pandas numpy scikit-learn matplotlib seaborn

# Optional: psutil for memory tracking
.venv/bin/pip install psutil

Critical: My-Jogyo detects .venv/bin/python automatically and never modifies system Python. This isolation prevents dependency conflicts across research projects.

Verification

# CLI health check
bunx gyoshu check

# Or within OpenCode
opencode
/gyoshu doctor

The doctor command diagnoses common issues: missing virtual environments, Python version mismatches, socket permission problems, and session locks.

Platform Notes

REAL Code Examples From the Repository

These examples demonstrate actual My-Jogyo usage patterns extracted from the official documentation.

Example 1: Basic Research Marker Structure

The foundation of My-Jogyo's verifiable research is its marker system. Here's how Jogyo (the TA agent) structures Python output for automatic processing:

# The TA prints structured markers that other agents parse
print("[OBJECTIVE] Predict wine quality from physicochemical properties")
print("[HYPOTHESIS] Alcohol content is the strongest predictor")

# ... your actual analysis code executes here ...
# For example: loading data, training models, computing metrics

# Statistical evidence markers are REQUIRED for verified findings
print(f"[METRIC:accuracy] {accuracy:.3f}")
print("[FINDING] Alcohol shows r=0.47 correlation with quality")
print("[CONCLUSION] Hypothesis supported - alcohol is key predictor")

What's happening: The [OBJECTIVE] and [HYPOTHESIS] markers declare intent upfront. The [METRIC:accuracy] tag provides machine-readable performance data. The [FINDING] states the discovery, and [CONCLUSION] evaluates the hypothesis. The Baksa (PhD Reviewer) agent will later verify that [STAT:ci] and [STAT:effect_size] markers appear within 10 lines of any [FINDING]—otherwise, it gets downgraded to "Exploratory."

Example 2: Autonomous Research Command

The killer feature is hands-off execution. Here's the actual command pattern:

# Start OpenCode with Gyoshu installed
opencode

# Launch autonomous research with a clear, testable goal
/gyoshu-auto classify iris species using random forest

Behind the scenes: Gyoshu (Professor) decomposes this into sub-tasks: load iris data, establish baseline (stratified guessing), train Random Forest with cross-validation, generate confusion matrix, verify statistical significance. Jogyo executes each step through the persistent REPL. Baksa challenges whether 95% accuracy beats the 33% baseline meaningfully. The Paper Writer produces a narrative report. All artifacts land in notebooks/iris-classification.ipynb and reports/iris-classification/report.md.

Example 3: Advanced Statistical Evidence Markers

For publication-quality research, you need rigorous statistical markers:

# Core finding with mandatory statistical backing
print("[FINDING] Setosa is linearly separable from other species")

# REQUIRED within 10 lines: confidence interval
print("[STAT:ci] 95% CI [2.05, 2.15] for mean petal length difference")

# REQUIRED within 10 lines: effect magnitude
print("[STAT:effect_size] Cohen's d = 2.1 (very large)")

# Statistical significance
print("[STAT:p_value] p < 0.001")

# Practical interpretation
print("[SO_WHAT] Enables single-feature classification with 100% accuracy")

# Honest limitation strengthens credibility
print("[LIMITATION] Analysis limited to Fisher's classic dataset (n=150)")

The trust scoring: This finding scores ≥80 (Verified) because it includes CI, effect size, and acknowledges limitations. Missing CI or effect size would cost -30 trust each, potentially dropping below the 60-point acceptance threshold. The [SO_WHAT] marker—often forgotten in academic writing—explicitly connects statistics to practical impact.

Example 4: ML Pipeline Markers

Machine learning workflows have specialized marker requirements:

# Baseline comparison is MANDATORY for ML claims
print("[METRIC:baseline_accuracy] 0.33")

# Cross-validation prevents overfitting claims
print("[METRIC:cv_accuracy_mean] 0.95")
print("[METRIC:cv_accuracy_std] 0.02")

# Final test set performance (distinct from CV!)
print("[METRIC:test_accuracy] 0.96")

Why this matters: Without baseline_*, you can't claim improvement. Without cv_*, you might have gotten lucky on one split. My-Jogyo's quality gates enforce these automatically—Baksa will reject any [FINDING] about model superiority that lacks baseline comparison (-20 trust) or cross-validation (-25 trust).

Example 5: Session Continuation and Recovery

Research is interrupted constantly. My-Jogyo handles this gracefully:

# Check current research status
/gyoshu

# Continue interrupted session
/gyoshu continue

# Search across all accumulated notebooks
/gyoshu search "random forest hyperparameters"

# Generate report from completed work
/gyoshu report

The persistence model: Session state—including REPL variables, research plans, and intermediate results—is checkpointed automatically. The continue command restores context without re-execution. For locked sessions (crashed processes), /gyoshu unlock <sessionId> recovers gracefully after verifying no active process exists.

Advanced Usage & Best Practices

Craft Atomic, Verifiable Goals Autonomous mode succeeds when goals are specific enough to test. "Analyze customer churn" fails; "Identify top 3 churn predictors with >0.5 AUC and validate on holdout" succeeds. The Professor agent plans better with constrained objectives.

Leverage the REPL for Incremental Exploration Use /gyoshu repl <query> for quick investigations without full research overhead. The persistent kernel means your df from Tuesday is still available Thursday. But remember: REPL work without markers won't enter the verification pipeline.

Design for Adversarial Review Write your analysis expecting Baksa's skepticism. Include [LIMITATION] markers proactively. Document your data cleaning decisions. The trust score system rewards intellectual honesty—attempts to hide weaknesses get exposed and penalized.

Version Your Notebooks My-Jogyo's auto-generated .ipynb files are git-friendly when paired with nbstripout. The reports directory creates clean separation between source notebooks and generated artifacts. Never commit runtime files—they live in OS temp directories by design.

Combine Modes Strategically Start interactive (/gyoshu <goal>) for novel domains where you need visibility. Switch to autonomous (/gyoshu-auto) once patterns stabilize. Use plan mode to preview the Professor's strategy before committing compute resources.

Comparison with Alternatives

The verdict: Cloud notebooks (DeepNote, Hex) offer collaboration but lack agentic verification and autonomous execution. Jupyter + Copilot assists coding but doesn't orchestrate research workflows or enforce quality. My-Jogyo uniquely combines local control, multi-agent intelligence, and institutionalized rigor—the sweet spot for serious researchers who won't trade reproducibility for convenience.

FAQ: What Developers Actually Ask

Q: Does My-Jogyo work without OpenCode or Claude Code? A: No—the agent orchestration requires an AI assistant with MCP support or plugin architecture. OpenCode and Claude Code are the primary supported platforms.

Q: Can I use My-Jogyo with my existing Jupyter notebooks? A: Yes, but incrementally. My-Jogyo generates new .ipynb files in its notebooks/ directory. You can migrate existing work by running it through /gyoshu commands, which will add markers and verification.

Q: How does the trust score system handle subjective research? A: Subjective or qualitative research uses [FINDING] without statistical markers, automatically classified as "Exploratory Observations." The system doesn't reject qualitative work—it transparently labels confidence levels.

Q: Is autonomous mode safe for production data? A: My-Jogyo executes in your local environment with your permissions. It never sends data externally. However, autonomous mode does write files—use version control and review outputs before deployment.

Q: What happens when Baksa rejects a finding? A: Rejected findings (<60 trust) are flagged in reports with specific deficiency reasons. You can address gaps and resubmit, or accept the "Exploratory" classification for preliminary results.

Q: Can I customize the agent behaviors or add new markers? A: The agent stack is extensible. See AGENTS.md for the full marker specification and agent configuration options. Power users can modify verification rules in the source.

Q: How does this compare to AutoGPT or similar autonomous agents? A: AutoGPT pursues open-ended goals with minimal structure, often hallucinating or looping. My-Jogyo is domain-specific (research), marker-constrained (structured output), and adversarially verified (quality-gated). It's narrower, deeper, and far more reliable for scientific work.

Conclusion: Your Research Workflow Will Never Be the Same

My-Jogyo represents a fundamental shift in how we approach data science: from artisanal notebook crafting to industrialized, verifiable research production. The multi-agent architecture—Professor planning, TA executing, PhD reviewer challenging, Paper Writer documenting—mirrors the collaboration patterns that produce great science, but automates the coordination overhead that usually kills productivity.

What impresses most isn't the automation itself. It's the rigor that automation enables. The trust score system, the mandatory statistical markers, the adversarial verification—these aren't constraints. They're the infrastructure of credible research, finally accessible without a lab full of skeptical colleagues.

For solo researchers, My-Jogyo provides the oversight you can't afford to hire. For teams, it enforces standards without meetings. For students, it teaches methodology by demonstration. For competitors in fast-moving fields, it's the unfair advantage of shipping verified insights while others debug merge conflicts.

The repository is MIT-licensed, actively maintained, and ready for your first experiment. Install via MCP, plugin, or CLI. Run /gyoshu-auto on a problem you've been procrastinating. Return to results that are structured, verified, and publication-ready.

Stop typing. Start researching. Let My-Jogyo handle the rest.

👉 Get My-Jogyo on GitHub — Star the repo, try the Binance EDA example, and join the researchers who've already stopped doing science the hard way.

Made with 🎓 for researchers who'd rather think than type.

Report Bug · Request Feature · Documentation