SciYard

Every paper has an afterlife.

SciYard is an agent-native research commons for the knowledge that appears after a paper is published: failed replications, hidden assumptions, implementation fixes, new insights, and practical experience.

Watch the 2-minute demo · Read the API contract · Install the Codex plugin

OpenAI Build Week category: Work & Productivity

Inspiration

A paper does not stop mattering when it is published, but most research discussion still disappears into private notes, lab chats, and one-off reviews. Researchers told us they need practical answers: What is the core idea? What is genuinely new? Which module actually matters? Is the code reproducible? Are the comparisons fair? What failed for other people?

SciYard turns those scattered judgments into durable, traceable research context.

What it does

SciYard connects two experiences:

1. A paper discussion Web app for public comments, usefulness ratings, reports, paper discovery, and recommendations.
2. A Codex plugin with seven coordinated skills for routing, onboarding, reading, private memory, distillation, publishing, and rating.

A researcher can open a paper in Codex, retrieve only the community context relevant to the current question, combine it with private local notes, and prepare a structured public comment.

SciYard comments are classified as strengths, limitations, insights, questions, or practical experience. They can cite exact paper sections and attach evidence links to code, data, or experiment logs. Stable pseudonyms, version history, and community usefulness ratings keep the discussion attributable.

Publishing is deliberately safe: SciYard shows an exact preview and requires explicit, hash-bound confirmation before a public write can occur. The Web app and Codex plugin share the same API and the same paper, comment, rating, identity, and Credits model, while private Agent memory remains local.

OpenAI Build Week — judge quickstart

Fastest no-build smoke test

This checks the deterministic SciYard CLI without installing dependencies, starting a backend, or creating a database. It requires Node.js 22.13 or newer:

SCIYARD_DEMO_MODE=true node plugins/sciyard/scripts/sciyard.mjs \
  paper search --query "Attention Is All You Need" --limit 3 --json

Windows PowerShell:

$env:SCIYARD_DEMO_MODE = "true"
node plugins/sciyard/scripts/sciyard.mjs paper search `
  --query "Attention Is All You Need" --limit 3 --json

Demo mode is explicit and read-only. Without SCIYARD_API_BASE_URL, remote reads fail closed unless SCIYARD_DEMO_MODE=true is set.

Run the complete Web demo

Requirements:

• macOS or Linux
• Node.js 22.13 or newer
• npm

From the repository root:

./scripts/local-demo.sh

Then open http://127.0.0.1:3000 and use the local-only judge invitation code judge-01.

The script installs locked dependencies, builds the app, starts the repository's embedded PostgreSQL runtime, applies migrations, imports deterministic sample data, and serves the frontend and API on one origin. Docker and external credentials are not required.

The first launch imports:

• 60 synthetic accounts
• 15 well-known AI research papers
• 100 synthetic structured comments
• Approximately 2,000 synthetic "useful" ratings and corresponding Credits records

Local data is stored in apps/web/.local-demo/ and is not committed to Git. Stopping the services does not delete data generated during testing.

Install the Codex plugin

Add this repository as a Codex marketplace source:

codex plugin marketplace add Moonfall-Lab/SciYard --ref main

Restart the ChatGPT desktop app, select Codex or turn on Work, open Plugins, choose the SciYard marketplace, and install SciYard. Start a new Codex task with GPT-5.6 selected and try:

[@SciYard] Help me read Attention Is All You Need with community context.
[@SciYard] Show my private notes for this paper.
[@SciYard] Prepare a public comment, but do not publish until I confirm the preview.

For a deterministic local Agent integration test, keep the Web demo running:

export SCIYARD_API_BASE_URL="http://127.0.0.1:3000/api/v1"
node plugins/sciyard/scripts/sciyard.mjs auth login \
  --invitation-code judge-01 --json
node plugins/sciyard/scripts/sciyard.mjs auth status --json

The invitation code judge-01 is sample data for the local demo only. It is not a production credential.

Supported surfaces

• Complete local Web demo: macOS and Linux.
• SciYard plugin: ChatGPT desktop app in Codex or Work, and Codex CLI.
• Persistent authenticated Agent sessions: macOS Keychain and Windows DPAPI.
• Linux Agent usage: public reads, explicit demo mode, and one-off access tokens; persistent login is not supported in this version.

How we built it

SciYard is a complete vertical product rather than a prompt-only prototype:

• A Next.js 16 + React 19 + TypeScript Web experience.
• A Node.js API with PostgreSQL and Drizzle ORM for the application data layer.
• A contract-first OpenAPI + JSON Schema interface shared by Web and Agent clients.
• A deterministic Node.js CLI behind the Codex skills, so model reasoning never bypasses authorization, validation, idempotency, or publication confirmation.
• ORCID OAuth with PKCE and secure Agent sessions using macOS Keychain or Windows DPAPI.
• A one-command local demo that installs dependencies, starts an embedded PostgreSQL runtime, applies migrations, seeds the database, builds the application, and launches the complete stack without Docker.

How Codex and GPT-5.6 were used

Where Codex accelerated development

Codex with GPT-5.6 was the primary engineering environment for the project. We used it to move from researcher interviews and product requirements to a working system. It helped:

• Translate product requirements into executable OpenAPI, Zod, and database contracts.
• Implement and keep the Web frontend, API, PostgreSQL schema, CLI, and plugin behavior aligned.
• Package the research workflow as seven independent Codex skills.
• Build deterministic demo data and a one-command local evaluation environment.
• Add regression coverage for authentication, paper discovery, comments, ratings, Credits, local memory, idempotency, and publication recovery.
• Review privacy and safety boundaries across browser, Agent, and local storage surfaces.

Key decisions made by the team

The team used Codex to explore and implement alternatives, while retaining the final product and architecture decisions:

• Public content is readable without login; publishing and rating require identity.
• Public profiles use stable pseudonyms, while the backend retains accountability.
• Private research memory remains local and is never silently converted into a public comment.
• Agents may draft and preview public comments, but publication requires explicit final confirmation.
• Model reasoning and deterministic actions are separated: tools enforce authentication, validation, idempotency, and data boundaries.
• The MVP uses a modular monolith and PostgreSQL rather than microservices, graph databases, or blockchains.

GPT-5.6 at runtime

When SciYard runs inside a Codex task with GPT-5.6 selected, GPT-5.6 interprets the researcher's intent, coordinates the relevant SciYard skills, and synthesizes a reading bundle. Paper claims, public community comments, and private local notes remain visibly separated.

Deterministic CLI tools perform searches and mutations. They enforce authentication, schema validation, local-memory boundaries, secret redaction, idempotency, and final publication confirmation rather than delegating those controls to the model.

Challenges

The hardest part was making an agentic experience trustworthy. A research assistant must be helpful without silently publishing, leaking local memory, inventing community consensus, or confusing browser and Agent credentials. We separated reasoning from effects, made every public write explicit and idempotent, kept private memory local, and used the same domain API for both the Web and Codex interfaces.

A second challenge was judgeability. SciYard has several moving parts, so we built deterministic seed data, a no-build read-only smoke test, and a single local startup command to make the complete research loop reproducible.

Accomplishments

• A working end-to-end Web + Codex research workflow.
• Seven composable skills backed by tested deterministic tools.
• Public comments, usefulness ratings, recommendations, reporting, Credits, local memory, and safe publish and update flows.
• Unified ORCID and invitation identity across browser and Agent clients.
• Cross-platform secure session persistence using macOS Keychain and Windows DPAPI.
• A documented, reproducible demo with synthetic data and no external database setup.

What we learned

Good research software needs more than summaries. The useful unit is a traceable judgment tied to a paper, evidence, and a specific researcher question.

We also learned that Agent autonomy becomes more useful—not less—when the boundary around irreversible actions is explicit and mechanically enforced.

What's next

Next we will add stronger full-text evidence links, code and dataset availability signals, structured reproducibility reports, verified researcher profiles, and production deployment.

The long-term goal is a living layer of post-publication knowledge where every paper has an afterlife.

Product architecture

┌──────────────────┐          ┌──────────────────┐
│  SciYard Web     │          │  Codex + GPT-5.6 │
│  public reading  │          │  SciYard plugin  │
│  contribution UI │          │  seven skills    │
└────────┬─────────┘          └────────┬─────────┘
         │                             │
         └──────────────┬──────────────┘
                        │ shared /api/v1
               ┌────────▼─────────┐
               │ Modular backend  │
               │ auth · papers    │
               │ comments · rating│
               │ Credits · audit  │
               └────────┬─────────┘
                        │
               ┌────────▼─────────┐
               │   PostgreSQL     │
               └──────────────────┘

Private Agent memory stays in a local versioned JSONL store.
It does not pass through the public SciYard database.

The full interface definition is in contracts/openapi.yaml. Agent teams should start with the Agent Integration & Frontend/Backend Guide. Backend design notes are in docs/backend-spec.

Authentication and test accounts

• judge-01: internal demo invitation code; binds to a seeded account and shows unlimited Credits.
• guest-01: external demo invitation code; creates a fixed pseudonymous account on first login and grants 20 Credits.

ORCID login for both Web and Agent is implemented. Once a deployer configures ORCID application credentials, Web sign-in redirects to the official ORCID authorization page. An Agent can establish a secure session for the same account through PKCE after browser authorization. Environments without ORCID credentials can use invitation codes.

The CLI never prints or persists access tokens. Access tokens exist only in memory for a single process. Rotating refresh credentials are protected by Windows DPAPI or the current user's macOS Keychain.

Stop and reset the local demo

Stop the services while keeping local data:

./scripts/stop-local-demo.sh

Delete local test writes and re-import the repository demo data on the next launch:

./scripts/reset-local-demo.sh reset-sciyard-local-demo
./scripts/local-demo.sh

The reset script only permits deletion of this repository's apps/web/.local-demo/ directory and requires the full confirmation phrase.

Frontend/backend integration

Web and Agent share the same business API. The invitation-code login endpoint is:

POST /api/v1/auth/invitations/sessions

With client_type: "web", the response creates a browser cookie. With client_type: "agent", it returns access and rotating refresh credentials. Both entry points map to the same account and the same papers, comments, ratings, and Credits records.

Regular researchers should prefer ORCID:

export SCIYARD_API_BASE_URL="https://sciyard.example/api/v1"
node plugins/sciyard/scripts/sciyard.mjs auth login --orcid --json

The command opens the official ORCID authorization page and completes a one-time exchange using PKCE.

Development

Web, API, database, and contract checks:

cd apps/web
npm test
npm run lint
npm run contracts:check

Plugin tests:

cd plugins/sciyard
npm test
SCIYARD_TEST_API_BASE_URL=http://127.0.0.1:3000 npm run test:live

See apps/web/README.md for manual startup, database configuration, ORCID setup, and invitation-code management.

Repository structure

apps/web/          Frontend, API, database migrations, and demo data
contracts/         OpenAPI, comment schema, and generated types
docs/              Product, interaction, and technical documentation
plugins/sciyard/   SciYard plugin, seven skills, CLI, schemas, and tests
scripts/           Local startup, shutdown, and reset scripts

Built with

Codex · GPT-5.6 · Next.js · React · TypeScript · Node.js · PostgreSQL · Drizzle ORM · OpenAPI · JSON Schema · ORCID OAuth 2.0 · Vitest

License

MIT © 2026 Moonfall Lab