Turn a client RFP into a priced SOW in 2 minutes — built for agencies, consultancies, and SIs.
Drop in an RFP. Nine AI agents work through a visual pipeline and return a complete Statement of Work — phases, effort, rate-carded costs, schedule, risks — in under two minutes. Runs local, so the client's IP never leaves your machine.
Agencies, consultancies, and SIs spend days or weeks scoping every RFP — re-reading requirements, applying rate cards, cross-referencing past engagements, building schedules, writing the SOW. Same process, every pitch.
Scoper runs 9 specialized AI agents in a configurable drag-and-drop pipeline. Upload the RFP, choose your workflow, and get a priced SOW (phases, effort hours, rate-carded costs, resources, schedule, flagged risks) — fast enough to turn a qualifying call into a priced proposal before the end of the day.
Why agencies in particular: every RFP you receive is confidential. Scoper runs fully local with Ollama, so client IP stays on your machine. No SaaS, no API keys, no data leakage. Your rate card, your delivery methodology, your agents — all configurable in YAML.
- Visual Pipeline Builder — drag-and-drop canvas (React Flow) with 28 node types across 6 categories
- 9 AI Agents — each with a distinct "soul" (personality, expertise, tools, memory access)
- 5-Layer Memory System — with Ebbinghaus decay for learning across estimates
- 5 Workflow Templates — Quick, Standard, Enterprise, Re-Estimate, Jira
- Built-in Validation — MAP framework, quality gates, full audit trail
- Configurable LLM Providers — OpenAI, Anthropic, GitHub Models, or fully local via Ollama
- Pure TypeScript NLP — TF-IDF, cosine similarity, domain detection — zero ML dependencies
- Zero Licensing Cost — fully open-source stack
- Single Command —
python run.pyserves everything on port 8005
- Python 3.10+
- Node.js 18+ (for frontend development)
- An LLM provider (see options below)
Use any of: OpenAI, Anthropic, or GitHub Models.
git clone https://github.com/parallelromb/scoper.git
cd scoper
# Copy and configure environment
cp .env.example .env
# Edit .env — set your preferred LLM provider and API key
# Install Python dependencies
pip install -r requirements.txt
# Build the frontend
cd frontend && npm install && npm run build && cd ..
# Launch (serves frontend + API on port 8005)
python run.pyOpen http://localhost:8005 and log in with any username.
Run completely offline with no API keys. Requires 16 GB+ RAM for larger models.
# 1. Install Ollama (macOS, Linux, or Windows)
# macOS:
brew install ollama
# Linux:
curl -fsSL https://ollama.com/install.sh | sh
# 2. Pull a model
ollama pull gemma3:27b # Best quality — needs 16 GB+ RAM
# OR
ollama pull gemma3:12b # Good balance — needs 8 GB+ RAM
# OR
ollama pull gemma3:4b # Lightweight — runs on 4 GB+
# 3. Start Ollama (runs on port 11434)
ollama serve
# 4. Clone and configure Scoper
git clone https://github.com/parallelromb/scoper.git
cd scoper
cp .env.example .env
# Edit .env:
# LLM_PROVIDER=ollama
# OLLAMA_HOST=http://localhost:11434
# OLLAMA_MODEL=gemma3:27b
pip install -r requirements.txt
# Build the frontend
cd frontend && npm install && npm run build && cd ..
python run.py| Model | Min RAM | Recommended For |
|---|---|---|
gemma3:27b |
16 GB | Full accuracy — desktops, workstations, cloud VMs |
gemma3:12b |
8 GB | Good balance — most laptops and small VMs |
gemma3:4b |
4 GB | Quick iteration — constrained environments |
Scoper is platform-agnostic: macOS, Linux, Windows (WSL2), or any cloud VM.
┌─────────────────────────────────────────────────────┐
│ Browser (SPA) │
│ React + Vite + Tailwind + React Flow + Zustand │
│ ┌───────────┐ ┌──────────┐ ┌────────────────────┐ │
│ │ Pipeline │ │ NLP │ │ Pipeline Executor │ │
│ │ Builder │ │ Engine │ │ (topological sort) │ │
│ └───────────┘ └──────────┘ └────────────────────┘ │
└──────────────────────┬──────────────────────────────┘
│ REST + WebSocket
┌──────────────────────▼──────────────────────────────┐
│ FastAPI Backend (port 8005) │
│ ┌──────────┐ ┌──────────┐ ┌───────────────────┐ │
│ │ Auth │ │ 60+ API │ │ Agentic Layer │ │
│ │ (cookie) │ │ Endpoints│ │ 9 agents, orchest.│ │
│ └──────────┘ └──────────┘ └───────────────────┘ │
│ ┌──────────┐ ┌──────────┐ ┌───────────────────┐ │
│ │ SQLite │ │ Memory │ │ LLM Router │ │
│ │ (WAL) │ │ 5 layers │ │ OpenAI/Anthropic/ │ │
│ └──────────┘ └──────────┘ │ GitHub/Ollama │ │
│ └───────────────────┘ │
└──────────────────────────────────────────────────────┘
| Agent | Role | Expertise |
|---|---|---|
| ARIA | Requirements Analyst | Extract & structure requirements, gap analysis |
| NOVA | Estimation Engine | Generate effort/cost/resource estimates |
| SENTINEL | Security Reviewer | Identify security risks & compliance issues |
| ATLAS | Architecture Advisor | Evaluate technical architecture implications |
| CHRONOS | Schedule Planner | Build timelines, identify critical paths |
| ORACLE | Historical Analyst | Cross-reference past estimates & outcomes |
| NEXUS | Integration Specialist | Assess integration complexity & dependencies |
| PRISM | Quality Analyst | Define quality gates & testing strategies |
| FORGE | DevOps Advisor | Infrastructure, CI/CD, deployment planning |
Input Sources (4) — Document Upload, API Input, Jira Import, Manual Entry AI Agents (8) — One per agent + composite node Tools (4) — Rate Card, Calendar, Template, Export Processing (4) — Decision Gate, Checkpoint, Merge, Filter Output (4) — Report, Dashboard, Excel, HTML Optimize (4) — Cache, Parallel, Retry, Validate
5-layer memory with Ebbinghaus decay:
| Layer | Purpose | Decay Rate |
|---|---|---|
| Working | Current session context | None (session-scoped) |
| Short-term | Recent estimates & patterns | Fast (hours) |
| Long-term | Historical outcomes & learnings | Slow (weeks) |
| Semantic | Domain knowledge & relationships | Very slow (months) |
| Episodic | Specific event recall | Medium (days) |
All configuration is in .env. See .env.example for the full list (16 variables).
Key settings:
# LLM Provider: openai | anthropic | github | ollama
LLM_PROVIDER=ollama
LLM_API_KEY=your-key-here # Not needed for Ollama
# Ollama settings (only when LLM_PROVIDER=ollama)
OLLAMA_HOST=http://localhost:11434
OLLAMA_MODEL=gemma3:27b
# Server
PORT=8005
HOST=0.0.0.0
# Auth
SESSION_TTL_HOURS=24# Frontend dev (hot reload)
cd frontend
npm install
npm run dev # Vite dev server on port 5173
# Backend dev
pip install -r requirements.txt
uvicorn server.app:app --reload --port 8005
# Build for production
cd frontend && npm run build # outputs to static/dist/
python run.py # serves SPA + API on port 8005scoper/
├── frontend/src/ # React app
│ ├── routes/ # 7 page components
│ ├── components/ # UI + pipeline + dashboard
│ ├── stores/ # 5 Zustand stores
│ ├── lib/ # Pipeline executor, NLP, node registry
│ ├── services/ # LLM chat API
│ └── types/ # TypeScript interfaces
├── server/ # FastAPI backend
│ ├── app.py # Main app
│ ├── routes/ # 13 route files (60+ endpoints)
│ └── services/ # Store, auth, memory
├── backend/ # Agentic AI layer
│ ├── agents/souls/ # 9 agent YAML definitions
│ ├── agents/skills/ # 13 skill pack YAMLs
│ ├── orchestrator/ # Pipeline engine
│ └── services/ # Chat, export, bridge
├── data/ # SQLite DB + uploads
├── static/dist/ # Built SPA
├── .env.example # Environment template
├── requirements.txt # Python dependencies
└── run.py # Entry point
| Template | Agents Used | Best For |
|---|---|---|
| Quick Estimate | ARIA → NOVA | Fast ballpark from a short doc |
| Standard | ARIA → NOVA → CHRONOS → PRISM | Full estimate with schedule |
| Enterprise | All 9 agents | Large, complex, multi-team projects |
| Re-Estimate | ORACLE → NOVA → SENTINEL | Revising an existing estimate |
| Jira Import | Jira Input → ARIA → NOVA → CHRONOS | Estimate from Jira tickets |
Scoper uses Smara for persistent cross-session memory. Smara provides the memory API that powers the 5-layer memory system, enabling agents to learn from past estimates and improve over time.
MIT License. See LICENSE for details.
Built with Claude Code | Scoper | MIT License