quetrex

barnent1/quetrex

3.2

If you are the rightful owner of quetrex and would like to certify it and/or have it hosted online, please leave a comment on the right or send an email to dayong@mcphub.com.

The Model Context Protocol (MCP) server is a crucial component of the Sentra platform, designed to facilitate autonomous AI development by managing model contexts and interactions with minimal human intervention.

Quetrex

Stop context switching. Start building.

A voice-first AI control center that lets you talk to your codebase and watch AI agents implement features while you review in-app.

Created by Glen Barnhardt with the help of Claude Code

Web App TypeScript Next.js

The Problem

You're building a feature. Here's what your workflow looks like:

  1. Open ChatGPT/Claude → describe what you want
  2. Copy code → paste into VS Code
  3. Realize it doesn't quite fit your architecture
  4. Back to AI chat → explain your codebase structure
  5. Copy more code → paste again
  6. Switch to terminal → npm test
  7. Tests fail → back to AI chat with error logs
  8. Finally works → manually create GitHub issue
  9. Write detailed spec (again, you just told the AI)
  10. Assign to yourself
  11. Open new terminal → git checkout -b feature/...
  12. Make changes → commit → push
  13. Open GitHub in browser → create PR
  14. Wait for CI/CD
  15. Review in GitHub UI (small viewport, no IDE context)
  16. Repeat for next feature...

30 minutes of context switching for what should be a 2-minute conversation.

Sound familiar?

The Solution

With Quetrex, you just talk:

"Add user authentication with email and password, magic link fallback, and session management"

Quetrex does the rest:

┌─────────────────────────────────────────────────────────────┐
│ 🎤 Architect AI (listening...)                              │
│                                                              │
│  "I'll create a spec for email/magic link authentication    │
│   with session management using NextAuth.js..."             │
│                                                              │
│  ✓ Database schema (User, Session, VerificationToken)       │
│  ✓ API routes (/api/auth/[...nextauth])                    │
│  ✓ Email provider integration                               │
│  ✓ Session middleware                                       │
│  ✓ Protected route HOC                                      │
│  ✓ Unit tests (90%+ coverage)                              │
│                                                              │
│  [Approve Spec] [Revise] [Cancel]                          │
└─────────────────────────────────────────────────────────────┘

  ↓ You click "Approve"

┌─────────────────────────────────────────────────────────────┐
│ 🤖 Agent: auth-feature-20251113 (running...)                │
│                                                              │
│  ✓ Created GitHub issue #42                                 │
│  ✓ Created branch: feature/email-magic-link-auth            │
│  ✓ Installed dependencies: next-auth, nodemailer           │
│  ✓ Created database schema (3 models)                      │
│  ✓ Generated API routes (5 endpoints)                      │
│  ✓ Added session middleware                                 │
│  ⟳ Running tests... (14/18 passing)                        │
└─────────────────────────────────────────────────────────────┘

  ↓ 8 minutes later

┌─────────────────────────────────────────────────────────────┐
│ ✅ Pull Request #43 Ready for Review                        │
│                                                              │
│  📝 feat: add email/magic link authentication               │
│  🔍 18 files changed (+847, -12)                           │
│  ✓ All tests passing (94% coverage)                        │
│  ✓ TypeScript checks passed                                │
│  ✓ Linting passed                                          │
│  ✓ Build successful                                         │
│                                                              │
│  [Review Changes] [Approve & Merge] [Request Changes]      │
└─────────────────────────────────────────────────────────────┘

Result: 30 seconds of talking. 8 minutes of implementation. Zero context switching.

You stay in Quetrex. No browser tabs. No terminal windows. No copying code.

What Makes Quetrex Different

1. Voice-First, Always

Most AI coding tools make you type. Quetrex makes you talk.

  • Natural conversation with AI architect about what you want to build
  • 2 implementations: HTTP API (works everywhere) + Realtime API (1-2s latency)
  • Smart context: Quetrex knows your codebase, your patterns, your standards
  • Versioned specs: See exactly what will be built before approving

2. Mission Control for Multiple Projects

Stop juggling terminal windows and GitHub tabs. See everything at once.

┌────────────────────────────────────────────────────────────────────────┐
│  📊 Quetrex Dashboard                                    🔔 3   ⚙️      │
├────────────────────────────────────────────────────────────────────────┤
│                                                                         │
│  🟢 quetrex-frontend               🟡 auth-service                      │
│  ├─ feat: PR review UI            ├─ fix: token refresh               │
│  ├─ ▓▓▓▓▓▓▓▓▓░░░░░ 67%          ├─ ▓▓░░░░░░░░░░░ 18%               │
│  └─ Agent: Building...  $1.23     └─ Waiting for approval  $0        │
│                                                                         │
│  ⚪ analytics-dashboard           🟢 api-gateway                       │
│  ├─ Idle                          ├─ feat: rate limiting               │
│  ├─ ░░░░░░░░░░░░░ 0%             ├─ ▓▓▓▓▓▓▓▓▓▓▓▓ 100%               │
│  └─ Ready  $0                     └─ PR ready for review  $2.45       │
│                                                                         │
│  [+ New Project]                                                       │
│                                                                         │
├────────────────────────────────────────────────────────────────────────┤
│  Recent Activity                                                       │
│  • auth-service: Tests passing (94% coverage)            2 mins ago   │
│  • api-gateway: Pull request #67 created                 8 mins ago   │
│  • quetrex-frontend: Agent started implementation         12 mins ago  │
└────────────────────────────────────────────────────────────────────────┘

Note: Dashboard redesign in progress - current version shows mock data

3. In-App PR Review (No GitHub Tab Needed)

Review, approve, and merge pull requests without leaving Quetrex.

  • Inline diff viewer with syntax highlighting
  • File tree navigation to jump between changes
  • Full Git visibility - see every commit, every change
  • One-click approval when everything looks good
  • Cost tracking - know exactly what each feature cost to build

4. Automation That Actually Works

Most CI/CD breaks when you need it most. Quetrex's automation is bulletproof.

6-Layer Defense System:

  1. PreToolUse Hook - Blocks dangerous commands before execution (git commit --no-verify → BLOCKED)
  2. PostToolUse Hook - Validates every file change (TypeScript errors, hardcoded secrets, any types)
  3. Stop Hook - Unbypassable quality gate (tests, coverage, linting, build, security audit)
  4. TypeScript Strict Mode - No escape hatches, no any, no @ts-ignore
  5. Test Coverage - 75%+ required (90%+ for business logic)
  6. CI/CD - GitHub Actions enforces everything again

Result: The 9-month bug that hides in a commit you forgot to test? Impossible.

5. Enterprise-Grade Security

Running AI agents that execute code is risky. We take security seriously.

3-Phase Security Model:

Phase 1: Docker Isolation (Implemented)

  • AI agents run in isolated containers on GitHub Actions
  • Read-only filesystem + ephemeral storage
  • Non-root execution with dropped capabilities
  • Resource limits: 2GB RAM, 2 CPU cores, 45-minute timeout
  • Risk reduction: 60-70%

Phase 2: Credential Proxy (Weeks 2-4)

  • Credentials never exposed to agent environment
  • Unix socket-based validation
  • Full audit trail of all API calls
  • Prevents prompt injection credential theft
  • Risk reduction: Additional 30% (CRITICAL)

Phase 3: gVisor Runtime (Q1 2026)

  • User-space kernel isolation
  • Industry-leading security (Claude Code for Web level)
  • Custom infrastructure with Google's gVisor
  • Risk reduction: Final 15%

See for complete design.

Current Status: Early But Working

Let's be honest about what's done and what's coming.

✅ What's Working Today

Voice Conversations

  • Two implementations (HTTP + Realtime API)
  • Natural language spec generation
  • Project context awareness
  • Conversation history

Spec Management

  • Automatic versioning (v1, v2, v3...)
  • Approval workflow
  • Markdown formatting with syntax highlighting
  • Rollback support

GitHub Actions Automation

  • Triggered by ai-feature label on issues
  • Docker container isolation (Phase 1 security)
  • Automatic PR creation
  • Progress updates via issue comments
  • 45-minute timeout protection

Quality Enforcement

  • All 6 defense layers operational
  • PreToolUse hook blocks dangerous operations
  • PostToolUse hook validates every change
  • Stop hook prevents finishing with failures
  • Git bypass is impossible

Web Application

  • Next.js 15 + React 19
  • TypeScript strict mode
  • Fast, responsive, works everywhere
  • Progressive Web App (PWA) support

🚧 What's In Progress

Dashboard Redesign (Weeks 1-2)

  • Multi-project card grid (currently single project focus)
  • True dark theme with violet accents
  • Real data instead of mocks
  • Drill-down detail panels

Agent Worker SDK (This Week)

  • Replacing non-existent CLI with Anthropic Python SDK
  • Multi-turn conversation implementation
  • Proper token tracking
  • Better error recovery

📋 What's Planned

Phase 2: Enhanced Features (Months 3-4)

  • Database layer (PostgreSQL + Prisma)
  • Multi-user teams
  • Real-time collaboration
  • Credential proxy service (Security Phase 2)
  • Mobile-responsive design

Phase 3: Enterprise Features (Months 5-6)

  • TOTP 2FA authentication
  • OAuth (GitHub, Google)
  • SSO integration
  • Advanced analytics
  • Team management dashboards

Phase 4: Enterprise (Months 7-12)

  • gVisor security (Phase 3)
  • Custom agent runners
  • Advanced analytics
  • Cost optimization
  • Team management

See for detailed plans.

Quick Start

Live Demo: https://quetrex.vercel.app

Local Development (5 Minutes)

# 1. Clone repository
git clone https://github.com/barnent1/quetrex.git
cd quetrex

# 2. Install dependencies
npm install

# 3. Set up environment
cp .env.example .env.local
# Edit .env.local and add:
#   OPENAI_API_KEY=sk-...
#   ANTHROPIC_API_KEY=sk-ant-...

# 4. Start the dev server
npm run dev

# 5. Open http://localhost:3000 in your browser

Web Deployment

Deploy to Vercel (Recommended):

npm install -g vercel
vercel

See for Netlify, Railway, or custom server deployments.

First Conversation

  1. Click "Chat with Architect" in the dashboard
  2. Click the microphone button
  3. Describe what you want to build:

    "Add a contact form with name, email, message fields. Validate email format. Store submissions in a database table. Send notification email to admin."

  4. Architect AI will ask clarifying questions
  5. Review the generated specification
  6. Click "Approve" to create GitHub issue and start automation

That's it. The agent takes over from there.

Technology Stack

Frontend (Web Application)

AI Services

Automation

Testing

Project Structure

quetrex/
├── src/                      # Next.js application
│   ├── app/                  # App Router pages
│   ├── components/           # React components
│   ├── lib/                  # OpenAI integration, utilities
│   ├── hooks/                # Custom React hooks
│   ├── services/             # Business logic
│   └── api/                  # API routes
│
├── .github/workflows/        # GitHub Actions
│   └── ai-agent.yml          # Agent automation workflow
│
├── .claude/                  # Claude Code configuration
│   ├── hooks/                # Quality enforcement (3 hooks)
│   │   ├── validate-bash.py  # PreToolUse (block dangerous commands)
│   │   ├── verify-changes.py # PostToolUse (validate edits)
│   │   └── quality-gate.sh   # Stop (unbypassable checks)
│   ├── scripts/
│   │   └── ai-agent-worker.py # Agent implementation worker
│   └── settings.json         # Agent configuration
│
├── .quetrex/                  # Project data
│   ├── specs/                # Versioned specifications
│   ├── memory/               # Project context
│   └── config.yml            # Automation settings
│
└── docs/                     # Documentation
    ├── architecture/         # System design, security
    ├── features/             # Feature documentation
    ├── deployment/           # Deployment guides
    └── roadmap/              # Future plans

Why Web Application?

Decision: November 2025 - Converted from Tauri desktop to web application

Reason: WKWebView on macOS cannot play WebRTC audio (Apple platform bug). Browser echo cancellation works perfectly in Chrome/Safari/Firefox. Voice is the core product.

Advantages:

  • Universal access - Works on any device with a browser
  • No installation - Instant access via URL
  • Perfect voice - Browser echo cancellation works flawlessly
  • Easy updates - Deploy once, everyone gets the update
  • Cross-platform - macOS, Windows, Linux, tablets, phones

Result: Echo cancellation now works reliably on all platforms. No more WKWebView limitations. Voice-first AI works perfectly.

Development

Commands

# Development
npm run dev              # Start Next.js dev server
npm run dev:safe         # Start dev server with crash recovery
npm run build            # Production build
npm run start            # Start production server

# Testing
npm test                 # Run tests in watch mode
npm test:run             # Run tests once
npm test:coverage        # Run with coverage report
npm test:e2e             # Run E2E tests (Playwright)

# Quality Checks
npm run type-check       # TypeScript compilation (strict mode)
npm run lint             # ESLint (0 errors, 0 warnings required)
npm run format           # Prettier formatting

Development Standards

TypeScript Strict Mode (Mandatory)

// ✅ DO: Explicit types
function calculateTotal(items: CartItem[]): number {
  return items.reduce((sum, item) => sum + item.price, 0)
}

// ❌ DON'T: Using 'any'
function processData(data: any) { }

// ❌ DON'T: Using @ts-ignore
// @ts-ignore
const value = getData()

Test-Driven Development (TDD)

  1. Write tests FIRST
  2. Verify tests FAIL
  3. Write implementation
  4. Verify tests PASS
  5. Refactor as needed

Coverage Requirements

  • Overall: 75%+
  • Business Logic (services): 90%+
  • Utilities: 90%+
  • UI Components: 60%+

Code Quality

  • ESLint: 0 errors, 0 warnings
  • Prettier: Enforced by pre-commit hooks
  • No console.log in production code
  • Input validation mandatory
  • No secrets in code (environment variables only)

See for complete guidelines.

Documentation

Quick Links

📚 - Everything in one place

🚀 - Get running in 10 minutes

🧪 - TDD workflow, coverage, E2E tests

🚢 - Production setup and configuration

🤝 - Development standards and best practices

Documentation Structure

Getting Started

  • - Prerequisites, setup, first run
  • - Setup and development workflow

Development

  • - TDD, coverage requirements, E2E tests
  • - Standards, Git workflow, quality hooks
  • Project Structure - File organization

Deployment

  • - Production setup, environment variables
  • - 3-phase security model

Architecture & Design

  • - Complete architecture overview
  • - Docker, credential proxy, gVisor
  • - Next.js App Router patterns
  • - Specification management
  • - Claude Code CLI approach

Features

  • - HTTP and Realtime API implementations
  • - Versioning and approval workflow
  • - Mission control interface
  • - Creating new projects
  • - GitHub Actions integration

Roadmap

  • - What's not done yet (honest status)
  • - Mission control vision
  • - Monitoring, logs, costs

Browse All Docs:

Real-World Example

Scenario: You need to add a real-time notification system to your app.

Traditional Workflow:

  1. Research WebSocket vs Server-Sent Events (30 minutes)
  2. Open ChatGPT, describe requirements (10 minutes)
  3. Copy/paste code, realize you need Redis (20 minutes)
  4. Install Redis, configure Docker Compose (30 minutes)
  5. Write tests (45 minutes)
  6. Debug failing tests (60 minutes)
  7. Create PR manually (15 minutes)
  8. Wait for review...

Total: 3+ hours of active work

Quetrex Workflow:

You: "Add real-time notifications using WebSockets. Store in
     Redis for multi-server support. Show toast notifications
     in UI. Support notification preferences per user."

Architect: "I'll design a WebSocket notification system with
           Redis pub/sub. Here's the spec..."

[8 minutes later]

Agent: "✓ Pull request #87 created
        - Added WebSocket server (Socket.io)
        - Redis pub/sub integration
        - Notification preferences model
        - Toast component with animations
        - 23 tests added (96% coverage)
        - All checks passing"

You: [Reviews in-app] "Looks good!"
     [Clicks Approve & Merge]

Done.

Total: 30 seconds of talking + 8 minutes of implementation + 2 minutes of review = 10 minutes

This is the future of development.

Contributing

We welcome contributions! This is an early-stage project with lots of opportunities to make an impact.

How to Contribute:

  1. Read
  2. Check Issues for good first issue label
  3. Fork the repo and create a feature branch
  4. Write tests FIRST (TDD approach)
  5. Ensure all quality checks pass
  6. Submit PR with clear description

Key Points:

  • TypeScript strict mode (no any, no @ts-ignore)
  • 75%+ test coverage required (enforced by CI/CD)
  • Quality hooks prevent bypassing checks
  • Write tests before implementation
  • Run npm run type-check && npm test && npm run lint before committing

Areas Needing Help:

  • Dashboard redesign (React components)
  • Linux/Windows testing
  • E2E test coverage
  • Documentation improvements
  • Agent worker SDK implementation

Vision

We're building the operating system for AI-powered development.

Today, Quetrex is a web application that helps you build features faster with voice and automation.

Future planned features:

  • Multi-user (teams, real-time collaboration)
  • Fully voice-controlled (never touch keyboard)
  • Hyper-personalized (learns your patterns, your style)
  • Cost-optimized (AI model selection, caching, smart retries)
  • Enterprise-ready (SSO, audit logs, compliance)
  • Mobile-optimized (iOS, Android PWA support)

The goal: Make building software as easy as having a conversation.

FAQ

Q: Does this replace developers? A: No. Quetrex makes developers more productive. You still make all the decisions - what to build, how to architect it, whether the implementation is correct. Quetrex just handles the tedious parts (writing boilerplate, running tests, creating PRs).

Q: What if the AI makes mistakes? A: That's why we have the 6-layer defense system and in-app PR review. Every change goes through TypeScript checks, linting, tests, and human review. Nothing gets merged without your approval.

Q: How much does it cost to run? A: Depends on usage. Typical costs:

  • Voice conversations: ~$0.01-0.05 per conversation (OpenAI)
  • Agent implementation: ~$0.50-3.00 per feature (Anthropic)
  • GitHub Actions: Free tier covers ~2000 minutes/month
  • Estimate: ~$10-30/month for active solo developer

Q: Is my code secure? A: Yes. See . Phase 1 (Docker isolation) is implemented. Phase 2 (credential proxy) is in progress. Phase 3 (gVisor) planned for Q1 2026.

Q: Can I use this in production? A: Quetrex itself is early-stage (use at your own risk). But the code Quetrex generates? Absolutely - just review it carefully like you would any PR.

Q: Does it work on mobile? A: The web interface is responsive and works on tablets. Full mobile optimization is planned for Phase 3.

License

MIT License - See file for details.

Credits

Created by: Glen Barnhardt with the help of Claude Code

Powered by:

Special Thanks:

  • Anthropic for Claude and the vision of helpful, honest, and harmless AI
  • OpenAI for pushing the boundaries of what's possible with voice
  • Vercel for making deployment effortless
  • The open-source community for inspiration and building blocks

Get Started

git clone https://github.com/barnent1/quetrex.git
cd quetrex
npm install
npm run dev

Questions? Open a GitHub Issue

Want to contribute? Read

Deploying? See

Follow progress: Star this repo and watch for updates

Stop context switching. Start building.

Talk to your codebase. Watch AI implement features. Review in-app. Merge with one click.

Try Live Demo | |