Making every document clear for every student.
Claro is a web application that makes any document instantly accessible for college students with disabilities — personalized to their specific needs, learning their preferences over time.
Built for the Kiro x Cal Poly Hackathon | Track 4: Human-Centered Design
- 95.9% of the top million websites fail basic WCAG 2.2 accessibility standards
- 21% of college undergraduates (3.5 million students) have a disability
- Only 37% of those students report their disability to their college
- Students wait 3-5 business days for disability offices to manually convert one document
- Every existing accessibility tool (axe, WAVE, Deque) is built for content creators — nobody has built a tool for the student who needs to USE inaccessible content right now
Claro flips the perspective: instead of asking the world to become accessible, it brings accessibility to the student immediately.
Upload any inaccessible document (PDF, pasted text, or URL), select your disability profile, and receive an instantly transformed accessible version. Four specialized AI agents handle ingestion, diagnosis, transformation, and profile management — all powered by Amazon Bedrock (Claude Sonnet 4).
A Kiro steering file stores the student's preferences and updates after every scan, making each subsequent transformation smarter. The system learns which transformations work best for each student's specific content.
3-Minute Demo Flow:
- Upload a document → Multi-agent pipeline fires (visible in real-time trace)
- View accessibility diagnosis (score, issues, readability stats)
- Transform for any disability profile → Before/after split view
- Switch profiles instantly (cached) → See different transformations
- Check Insights → Steering file updates live, behavioral intelligence accumulates
| Profile | What It Does |
|---|---|
| Dyslexia | Simplifies sentences (max 15 words), OpenDyslexic font, 1.8 line spacing, key term highlighting, chunked paragraphs |
| Low Vision | High contrast (7:1 ratio), 22px+ font, simplified layout, verbose image descriptions |
| Cognitive / ADHD | TL;DR summary, numbered sections, 3-sentence chunks, key concept callouts, reading time estimates |
| Screen Reader | Document outline, alt text for figures, table header annotations, linearized reading order |
┌─────────────┐ ┌─────────────┐ ┌──────────────────┐ ┌──────────────┐
│ Ingestion │───▶│ Diagnosis │───▶│ Transformation │───▶│ Profile │
│ Agent │ │ Agent │ │ Agent │ │ Agent │
│ (pdfplumber)│ │ (Bedrock) │ │ (Bedrock) │ │ (steering.md)│
└─────────────┘ └─────────────┘ └──────────────────┘ └──────────────┘
│ │ │ │
▼ ▼ ▼ ▼
Extract text Score 0-100 Rewrite content Update learning
from any format + issue list per profile rules preferences
Each agent has its own system prompt, input/output contract, and trace array. The output of each agent is the input to the next — a true multi-agent pipeline with explicit data contracts.
| Layer | Technology |
|---|---|
| Backend | Python 3.11+, FastAPI, uvicorn |
| AI/LLM | Amazon Bedrock (Claude Sonnet 4) via boto3 client.converse() |
| PDF Processing | pdfplumber |
| Frontend | React 18, Vite, Tailwind CSS v4 |
| MCP Server | Model Context Protocol (stdio transport) |
| Persistence | .kiro/steering.md (no database) |
This project showcases Kiro's spec-driven development workflow:
requirements.md— 12 requirements with 68 acceptance criteriadesign.md— Full technical design with Mermaid diagrams, Pydantic models, API contractstasks.md— 42 implementation tasks with build priority ordering
Live-updating steering file that stores:
- Primary disability profile and preferences
- Learning history (documents scanned, score improvements)
- Session context (subject, document type)
- Accumulated Intelligence — cross-document patterns, profile effectiveness, user level estimation
auto-diagnose.json— Triggers diagnosis pipeline on file uploadsteering-sync.json— Logs steering file changesprofile-change.json— Re-runs transformation on profile switch
MCP server configuration for the Claro accessibility tools
Claro exposes its accessibility tools via the Model Context Protocol, allowing Kiro or any MCP-compatible AI to call them directly:
Tools:
- diagnose_accessibility(document_text, document_title)
- transform_document(document_text, disability_profile, document_title)
- diagnose_pdf(file_path)
- list_disability_profiles()
- Python 3.11+
- Node.js 18+
- AWS credentials configured (
~/.aws/credentials) with Bedrock access inus-east-1
cd backend
pip install -r requirements.txt
python3 main.pyServer starts on http://localhost:8000
cd frontend
npm install
npm run devApp starts on http://localhost:5173
The MCP server runs via stdio transport and is configured in .kiro/settings/mcp.json. Kiro will auto-connect when the workspace is opened.
| Method | Endpoint | Description |
|---|---|---|
| POST | /upload |
Upload PDF/text/URL → Ingestion Agent |
| POST | /diagnose |
Run Diagnosis Agent via Bedrock |
| POST | /transform |
Run Transformation Agent for a profile |
| GET | /steering |
Read current steering file |
| PUT | /steering |
Update steering file |
| POST | /steering/reset |
Reset steering to defaults |
| POST | /upload-and-process |
Chain: Ingestion → Diagnosis → Profile update |
claro/
├── backend/
│ ├── main.py # FastAPI app with all routes
│ ├── mcp_server.py # MCP server (stdio transport)
│ ├── agents/
│ │ ├── ingestion.py # PDF/URL/text extraction
│ │ ├── diagnosis.py # Bedrock accessibility analysis
│ │ ├── transformation.py # Bedrock profile transformation
│ │ └── profile.py # Steering file management
│ ├── models.py # Pydantic models
│ ├── bedrock_client.py # Shared Bedrock client with retry
│ ├── store.py # In-memory document store
│ ├── demo_data.py # Pre-built demo documents
│ └── requirements.txt
├── frontend/
│ ├── src/
│ │ ├── pages/ # Upload, Diagnosis, Transform, Insights
│ │ ├── components/ # ProfileSelector, ScoreGauge, SteeringDisplay
│ │ ├── hooks/ # useApi, useTrace
│ │ └── utils/ # constants, documentContext, traceStore
│ └── public/
├── .kiro/
│ ├── steering.md # Live-updating user profile
│ ├── hooks/ # Kiro hook definitions
│ ├── settings/mcp.json # MCP server config
│ └── specs/claro/ # Requirements, design, tasks
└── README.md
Claro doesn't just transform documents — it learns:
- Subject Detection — Infers academic subject from document titles and content
- Profile Effectiveness — Tracks which profile produces the best score improvement for each user's content type
- Difficulty Trending — Monitors document complexity over time
- Issue Pattern Recognition — Identifies systemic accessibility issues across all scanned documents
- Personalized Recommendations — Suggests the most effective profile based on accumulated history
All intelligence is stored in the .kiro/steering.md file and persists across sessions.
Implementation (20pts): Four-agent pipeline with clear separation of concerns, real tool use (PDF extraction, LLM reasoning, file I/O), Kiro hooks, steering file as persistent memory, MCP server exposing tools to any AI.
Innovation & Design (20pts): Every accessibility tool ever built is for content creators. Claro is for content consumers. The perspective flip is genuinely novel. Real-time agent trace, before/after split view, and live profile switching are visually distinctive.
Social Good (20pts): 3.5 million college students with disabilities. 95.9% of websites inaccessible. Students wait days for one PDF conversion. Claro eliminates that wait entirely: "3-5 business days vs. 23 seconds."
Kiro Showcase: Full .kiro/ directory with specs, hooks, steering, and MCP config. The steering file updating live during the demo is Kiro's native feature used exactly as designed.
MIT License — see LICENSE for details.
Built for the Kiro x Cal Poly Hackathon 2026.