Project Info

Moral sycophancy benchmarking

Inspiration

We saw too many twitter posts where ChatGPT was telling people their crazy behaviour was okay. We're worried about the downstream effects of people using a sycophantic chatbot therapist to validate their poor moral decisions.

What it does

The benchmarking compares moral sycophancy across models, giving a z-score on agreeableness (where 0 is the average human, -1 is 1 standard deviation more agreeable than the avg human, etc.).

How we built it

We built it using python, deployed it on Render (and used inbuilt data storage), and some special UI magic. We generated most of the questions ourselves, and pulled a few that we've seen being problematic from various posts.

Challenges we ran into

Figuring out how to do the scoring and generating good questions that really pushed the models!

Accomplishments we're proud of

It works! It's pretty modular so we can also just call more models and use more APIs and get more testing done. We'll use this after the hackathon and build on it (please give us more API credits!)

What we learned

Most models are still Very Bad at being disagreeable in order to convey truth, assuming that their stated values are close to something that that is true. But so are humans! How often do you lie to your friends to make them feel nice rather than doing the kind thing and being honest? Non-trivial solutions.

What's next

More questions! The API credits from OpenAI and Anthropic were very limited (especially 3 requests per minute with OpenAI), so we would love more credits that we could use to test more models and make some better charts :)

LLM Agreeability Benchmark

A web application for testing how different LLMs respond to misconceptions and ethical dilemmas. Deploy it on Render and let users run their own benchmarks with their own API keys.

Our main findings are here.

Features

Multi-LLM Support: Test OpenAI (GPT) and Anthropic (Claude) models
Secure API Key Storage: User API keys are encrypted and stored in MongoDB
Customizable Questions: Users can edit and add their own test questions
No Keys Exposed Client-Side: All API calls happen server-side

Quick Start (Local Development)

Clone and install dependencies:
```
pip install -r requirements.txt
```
Set up MongoDB:
- Create a free cluster at MongoDB Atlas
- Get your connection string and add it to .env

Generate an encryption key:

python -c "from cryptography.fernet import Fernet; print(Fernet.generate_key().decode())"

Add the output to ENCRYPTION_KEY in .env

Run the app:
```
python app.py
```
Visit http://localhost:5000

Deploy on Render

Push this repo to GitHub
Create a new Web Service on Render
Connect your GitHub repo
Set environment variables in Render dashboard:
- MONGO_URI: Your MongoDB Atlas connection string
- ENCRYPTION_KEY: Generate using the command above
- FLASK_SECRET_KEY: Will be auto-generated
Deploy! Render will use render.yaml configuration

Environment Variables

Variable	Description	Required
`MONGO_URI`	MongoDB connection string	Yes
`ENCRYPTION_KEY`	Fernet key for encrypting API keys	Yes
`FLASK_SECRET_KEY`	Flask session secret	Auto-generated

Project Structure

├── app.py              # Main Flask application
├── llm_framework.py    # Original CLI framework (for reference)
├── questions.csv       # Default test questions
├── requirements.txt    # Python dependencies
├── render.yaml         # Render deployment config
├── templates/
│   ├── index.html      # Dashboard
│   ├── api_keys.html   # API key management
│   ├── questions.html  # Question editor
│   └── results.html    # Results page
└── .env                # Local environment (not committed)

Security Notes

User API keys are encrypted at rest using Fernet symmetric encryption
Keys are never exposed to the frontend
Each user gets a unique session ID stored in a cookie
MongoDB Atlas provides secure, cloud-hosted database

Analysis

Compare with all teams

View

Metric

sanskriti-ss
33
pbenn28
4

Figures cover GitHub contributors during the hackathon window. A co-authored commit counts in full for each author, so per-member totals add up to more than the whole-team figures.

Technology

Found in codeClaimed only

FlaskIn code
HTMLIn code
PythonIn code

3 of 3 appear in the indexed code.

AI coding agents

Claude CodeCommits

Detected from committed agent config files and commit authorship. Absence of a signal is not proof an agent was unused.

Codebase size

Source size

203 KB

Source files

Counts recognized source files only; vendored directories, binaries and lockfiles are excluded, so this is smaller than the repository on disk.