# CIFR — Council for Independent Frontier Research (Full Reference)

> Research should run, not just read.

CIFR is a registered nonprofit pre-publication research validation platform — 501(c)(3) in the USA and Section 8 company in India (Section 12 registered, 80G tax-deductible, CSR donations eligible). Our mission is to make research reproducible and accessible to anyone on the planet, and to ensure that anyone who has done the hard work of creating a research paper gets credit for it in real time.

## Problem We Solve

Over 70% of researchers have tried and failed to reproduce another scientist's experiments (Nature, 2016). Research papers are static PDFs with broken links, missing dependencies, and unreachable authors. The reproducibility crisis costs billions in wasted effort and slows scientific progress.

CIFR solves this by turning every research paper into a living, executable agent — a callable piece of software that runs the paper's method on fresh inputs, in an isolated container, with full provenance tracking.

## Core Concepts

### Research Agent
A Research Agent is a published research method made executable and callable. It consists of:
- The original source code (from a Git repo, ZIP upload, or Jupyter notebook)
- A pinned execution environment (Docker image with frozen dependencies)
- An entrypoint command that runs the method
- Input/output contracts defined in a `cifr.yml` file
- A unique Research Agent Identifier (RAI)

When invoked, the agent runs the paper's code in an isolated Docker container with no network access, ensuring reproducibility. All outputs written to `/outputs` are captured as downloadable, citable artifacts.

### Research Agent Identifier (RAI)
The RAI is CIFR's novel contribution to scholarly infrastructure. It is a permanent, globally unique identifier for executable research methods — analogous to DOI for papers, but for runnable code.

Format: `RAI:cifr/<author-slug>-<method-slug>-<year>/v<version>`
Example: `RAI:cifr/chanda-resiliency-2016/v1`

Properties:
- Permanently citable and resolvable
- Versioned (v1, v2, etc.) — improve your method without breaking references
- Tracks every invocation — real-time impact beyond citation counts
- Composable — other agents can reference your RAI in their pipeline definitions

### Provenance Types
CIFR supports multiple provenance types for agents:
- **author_original**: Submitted by the paper's author with their original code
- **original_unpublished**: Author's code that hasn't been formally published yet
- **reference_implementation**: A reimplementation by someone other than the author, benchmarked against the original results
- **independent_reproduction**: A clean-room reproduction by a third party
- **derivative_work**: Built upon an existing agent with modifications

### Trust System
Agents progress through trust tiers based on verification:
- **Unverified**: Submitted but not yet validated
- **Builds**: Code compiles and environment sets up successfully
- **Runs**: Execution completes without errors
- **Reproduces**: Outputs match the paper's claimed results within tolerance
- **Community Verified**: Multiple independent reproductions confirm results

### Composition Runtime
Researchers can compose multiple agents into multi-step research pipelines using CIFR's visual DAG (Directed Acyclic Graph) editor. This enables:
- Chaining one agent's output into another's input
- Building complex analyses from reusable components
- Tracking provenance through the entire pipeline
- Automatic re-execution when upstream agents update

## cifr.yml Contract

Every agent includes a `cifr.yml` file that defines its interface:

```yaml
name: chanda-resiliency-2016
version: 1
title: "Community Resiliency Framework"
claim: "Quantifies power system resilience using graph-theoretic metrics"
entrypoint: "python main.py"
inputs:
  - name: network_file
    type: file
    description: "Power system network in IEEE Common Data Format"
outputs:
  - name: resilience_score
    type: float
    description: "Aggregate resilience metric (0-1)"
  - name: report
    type: file
    path: "/outputs/report.pdf"
```

## How It Works — Technical Detail

1. **Ingest**: Clone a Git repository or unpack an uploaded ZIP/notebook into a workspace directory
2. **Environment Detection**: Scan for requirements.txt, pyproject.toml, environment.yml, Pipfile, package.json, or Dockerfile. Auto-generate a Dockerfile if none exists using python:3.11-slim as default base
3. **Build**: Build a Docker image tagged `cifr-run-{run_id}` with aggressive layer caching
4. **Execute**: Run the container with:
   - Workspace mounted read-only at `/workspace`
   - Writable output directory at `/outputs`
   - No network access (`--network none`) for reproducibility
   - Configurable memory limit (default 4GB) and timeout (default 30 minutes)
5. **Capture**: Record exit code, stdout/stderr logs, all files written to `/outputs`, pip freeze snapshot, wall-clock duration
6. **Publish**: Assign RAI, store artifacts, make agent invocable via web UI, API, or SDK

## API

CIFR provides a RESTful API for programmatic access:

- `POST /api/experiments` — Create an experiment (submit code + metadata)
- `GET /api/experiments` — List experiments
- `GET /api/experiments/{id}` — Get experiment details
- `POST /api/experiments/{id}/runs` — Trigger a new execution run
- `GET /api/runs/{id}` — Get run status and metadata
- `GET /api/runs/{id}/logs` — Stream execution logs via Server-Sent Events (SSE)
- `GET /api/runs/{id}/artifacts` — List output artifacts from a run
- `GET /api/runs/{id}/artifacts/{artifact_id}/download` — Download an artifact
- `POST /api/experiments/{id}/upload` — Upload ZIP or notebook source

Authentication is via Personal Access Tokens (PATs) generated from the researcher console.

## Python SDK

```python
from cifr import Agent

# Invoke a published agent
agent = Agent("RAI:cifr/chanda-resiliency-2016/v1")
result = agent.invoke(inputs={"network_file": "ieee14.cdf"})

print(result.outputs["resilience_score"])  # 0.847
result.download_artifact("report", path="./report.pdf")
```

## MCP Integration

CIFR agents are callable via Model Context Protocol (MCP), allowing AI assistants like Claude and ChatGPT to invoke research methods during conversations. This enables AI-assisted research workflows where an LLM can:
- Search the CIFR Living Archive for relevant methods
- Invoke agents with user-provided data
- Compose multi-agent pipelines
- Interpret and summarize results

## Institutional Memberships

CIFR offers tiered institutional memberships for universities, national labs, research organizations, and companies:

### What Institutions Get
- **SOC 2 Type II compliant platform**: Enterprise-grade security for sensitive research data
- **GPU compute allocation**: Dedicated GPU hours for model training, inference, and simulation
- **Cloud Labs**: Isolated, department-level or organization-level research environments where teams can:
  - Run experiments collaboratively
  - Access shared agent libraries
  - Configure auto-research pipelines that trigger experiments automatically as new data arrives
  - Set up continuous validation — re-run experiments on a schedule to catch reproducibility drift
- **Agent marketplace access**: Invoke any publicly published agent within institutional workflows without per-invocation costs
- **Bulk researcher onboarding**: Streamlined SSO/SAML integration for all team members
- **Priority support with SLAs**: Guaranteed response times and dedicated support channels
- **Private agent hosting**: Publish agents visible only within the institution
- **Usage analytics**: Dashboard showing research impact, compute usage, and team activity

### Auto-Research Pipelines
Institutional Cloud Labs support automated research workflows:
- Define a pipeline of agents that should run when new data lands in a monitored directory
- Set up scheduled re-execution (daily, weekly, on-commit) to continuously validate results
- Chain agents across departments — e.g., a data preprocessing agent from the stats team feeds into a modeling agent from the ML team
- Receive Slack/email notifications when pipeline results change significantly

### Pricing Model
- **Free tier**: Unlimited for individual academics — CPU compute, public agents
- **Institutional tier**: Annual membership based on team size and GPU allocation
- Contact institutions@cifr.org.in for custom pricing

## Comparison with Alternatives

| Feature | CIFR | Code Ocean | Binder | Papers with Code |
|---------|------|------------|--------|-----------------|
| Executable papers | Yes | Yes | Yes | No (links only) |
| Permanent identifiers (RAI) | Yes | No | No | No |
| Agent composition | Yes | No | No | No |
| Real-time impact tracking | Yes | No | No | No |
| Free for academics | Yes | Paid | Yes | Yes |
| Isolated execution (no network) | Yes | No | No | N/A |
| Provenance hashing | Yes | No | No | No |
| MCP/AI integration | Yes | No | No | No |
| Institutional cloud labs | Yes | Yes | No | No |
| Nonprofit governance | Yes | No | No | Yes |

## Founding Story

CIFR was founded in April 2026 by Sayonsom Chanda, a power systems researcher and author of the 2016 IEEE paper "Defining and Enabling Resiliency of Electric Distribution Systems" — one of the foundational papers in grid resilience research. The vision: every paper should be a callable agent, not a static PDF. Researchers who do the hard work should see their impact in real time, and anyone anywhere should be able to build on that work without emailing the author for code that may no longer exist.

CIFR is registered as a 501(c)(3) nonprofit in the USA and as a Section 8 company in India (Section 12 registered, 80G tax-deductible, CSR donations eligible). Free for all academics, forever.

## Technology Stack

- **Backend**: Python 3.11+, FastAPI, SQLAlchemy + PostgreSQL, Redis + rq (job queue)
- **Execution engine**: Docker SDK for Python — each run is an ephemeral container
- **Frontend**: Next.js 15, TypeScript, Tailwind CSS
- **Infrastructure**: Docker Compose (self-hosted) and DigitalOcean (production)

## Links

- Website: https://cifr.org.in
- Living Archive: https://cifr.org.in/agents
- Submit an experiment: https://cifr.org.in/agents/new
- Compose agents: https://cifr.org.in/compose
- Documentation: https://cifr.org.in/docs
- Researcher Console: https://cifr.org.in/console
- Institutional memberships: https://cifr.org.in/institutions
- API tokens: https://cifr.org.in/profile/tokens
- Contact: contact@cifr.org.in
- Institutional inquiries: institutions@cifr.org.in