DEVS - AI Agent Orchestration Platform

Project Vision

Democratize AI agent delegation with a universally accessible, privacy-conscious, open-source solution that runs entirely in the browser.

Core Concept

A browser-based AI orchestration platform that models real organizational dynamics, enabling users to delegate complex tasks to teams of AI agents that work together using proven business methodologies.

Key Features

1. Browser-Native Architecture

No server dependencies - Everything runs locally in the user's browser
Web technologies only - HTML, CSS, TypeScript, Service Workers, IndexedDB, WebAssembly
Privacy-first - All data stays on the user's device
Offline capable - Works without internet connection after initial load
Low-spec hardware support - Works on devices with 2GB RAM minimum
Accessibility-focused - Multi-language support, keyboard navigation, screen reader compatibility

2. AI Studio Features

Pre-built agent roles (CEO, Analyst, Developer, QA, etc.)
Custom agent personality and capability configuration
Real-time visualization of agent interactions and decisions

3. LLM Provider Independence

Support for multiple LLM providers:
- OpenAI, Anthropic, Google Gemini, Mistral, Ollama, Custom/Local endpoints
Secure token storage using Web Crypto API
Provider abstraction layer for seamless switching
Usage tracking and cost estimation

4. Hyper Meta-Prompting System

Multi-layered prompt generation:
- Base personality layer
- Role specialization layer
- Task context layer
- Dynamic adaptation layer
Prompt inheritance and composition patterns
Context-aware prompt compilation engine

5. Intelligent Multi-Agent Orchestration

The DEVS orchestration system implements autonomous multi-agent task coordination with intelligent analysis, team building, execution, and validation.

Architecture Overview

graph TB
    A[User Request] --> B[WorkflowOrchestrator]
    B --> C[TaskAnalyzer]
    C --> D{Complexity Assessment}
    D -->|Simple| E[Single-Pass Execution]
    D -->|Complex| F[Multi-Pass Execution]
    E --> G[Agent Execution]
    F --> H[Team Building]
    H --> I[Coordinated Execution]
    G --> J[Validation & Refinement]
    I --> J
    J --> K[Artifact Creation]
    K --> L[Final Results]

Core Orchestration Components

WorkflowOrchestrator (src/lib/orchestrator.ts)

Central coordination hub with deduplication prevention
Strategy selection: single-pass vs multi-pass execution
Comprehensive error handling and recovery
Agent recruitment and team building

TaskAnalyzer (src/lib/task-analyzer.ts)

LLM-powered prompt analysis
Requirement extraction (functional/non-functional/constraints)
Complexity assessment and skill identification
Intelligent task breakdown with domain-specific patterns:
- Creative Writing: Research → Character Development → Writing
- Development: Analysis & Design → Implementation
- Generic: Planning & Analysis → Execution & Delivery

Agent Management (src/stores/agentStore.ts)

Agent lifecycle: Discovery → Recruitment → Caching → Execution
Built-in agents from JSON + custom agents from Yjs
Dynamic agent creation via agent-recruiter
Skill matching and role assignment
Yjs-first storage: Direct writes to Yjs maps, reactive hooks for UI

Execution Strategies

Single-Pass Strategy:

For simple tasks (complexity: 'simple')
Find or create suitable agent
Execute with enhanced context
Validate and refine if needed

Multi-Pass Strategy:

For complex tasks requiring multiple agents
Break down into subtasks with dependencies
Build specialized agent teams
Coordinate parallel/sequential execution
Handle validation failures with refinement workflows

Team Coordination Engine

// Dependency resolution with parallel execution
coordinateTeamExecution(tasks, team) {
  while (executedTasks.size < tasks.length) {
    // Find tasks ready for execution (dependencies satisfied)
    const readyTasks = tasks.filter(task =>
      !executedTasks.has(task.id) &&
      task.dependencies.every(depId => executedTasks.has(depId))
    )

    // Execute in parallel batches (up to team size)
    const batch = readyTasks.slice(0, team.length)
    await Promise.all(batch.map((task, index) => {
      const agent = team[index % team.length]
      return executeTaskWithAgent(task, agent, task.description)
    }))
  }
}

Coordination Features:

Dependency resolution with topological sorting
Parallel batch execution up to team capacity
Round-robin load balancing
Circular dependency detection

Requirement Validation Engine

RequirementValidator (src/lib/requirement-validator.ts)

Validates three requirement types:

Functional Requirements: Feature implementation validation
- Evidence: code snippets, configuration, test results
Non-Functional Requirements: Performance, scalability, usability
- Evidence: performance reports, analysis documents
Constraints: Technology, time, resource limitations
- Evidence: architectural decisions, implementation choices

Validation Features:

Custom validator registration
Evidence-based validation with artifact analysis
Status tracking (satisfied/pending/failed)
Automatic refinement task creation on failure

Error Handling & Retry Mechanisms

Multi-Level Strategy:

Orchestration Level
- Duplicate prevention via prompt hashing
- Graceful degradation with fallback agent creation
- Transaction safety with rollback
Validation Level
- Automatic refinement tasks for validation failures
- Maintains original task context
- Iterative improvement cycles
Agent Level
- Fallback agent creation when recruitment fails
- Skill-based agent matching
- Dynamic team reconstruction
Network Level
- LLM provider fallbacks
- Timeout handling
- Multi-strategy response parsing

Context Sharing & Collaboration

ContextBroker (src/lib/context-broker.ts)

Enables intelligent information sharing between agents:

interface SharedContext {
  type: 'decision' | 'finding' | 'resource' | 'constraint'
  agentId: string
  content: string
  keywords: string[]
  expiresAt?: Date
}

Publish/subscribe pattern for inter-agent communication
Keyword-based context filtering
Automatic expiration and cleanup

Default DEVS Agent

Sophisticated orchestrator agent with:

Autonomous task analysis capabilities
Multi-agent coordination instructions
Requirement-driven execution approach
Self-correcting workflow logic

Agent Memory System

MemoryLearningService (src/lib/memory-learning-service.ts)

Enables agents to learn and remember information from conversations:

graph LR
    A[Conversation] --> B[Learning Extraction]
    B --> C[Memory Creation]
    C --> D{Human Review}
    D -->|Approve| E[Approved Memory]
    D -->|Reject| F[Discarded]
    D -->|Edit| G[Edited & Approved]
    E --> H[Context Injection]
    H --> I[Future Conversations]

Memory Categories:

Facts: Concrete information about the user or domain
Preferences: User preferences and working styles
Behaviors: Observed patterns and habits
Domain Knowledge: Technical or specialized knowledge
Relationships: Connections between concepts or people
Procedures: Step-by-step processes
Corrections: Rectifications of previous misunderstandings

Confidence Levels:

High: Explicitly stated, reliable information
Medium: Inferred with reasonable certainty
Low: Tentative conclusions requiring validation

Core Components:

AgentMemoryStore (src/stores/agentMemoryStore.ts)
- Memory CRUD operations with Yjs persistence
- Learning event tracking
- Memory document synthesis
- Bulk operations and cleanup
Memory Extraction
- LLM-powered extraction from conversations
- Automatic categorization and confidence scoring
- Keyword extraction for relevance matching
- Robust JSON parsing with sanitization
Human Review System
- Pending review queue for new memories
- Approve/reject/edit workflow
- Bulk operations support
- Review notes and audit trail
Context Injection
- Relevant memories injected into new conversations
- Keyword-based relevance scoring
- Confidence and recency boosting
- Usage tracking for analytics

Memory Data Schema:

interface AgentMemoryEntry {
  id: string
  agentId: string
  category: MemoryCategory
  title: string
  content: string
  confidence: MemoryConfidence
  source: 'conversation' | 'manual' | 'imported'
  sourceConversationId?: string
  keywords: string[]
  tags: string[]
  validationStatus: 'pending' | 'approved' | 'rejected' | 'auto_approved'
  reviewedAt?: Date
  reviewedBy?: string
  reviewNotes?: string
  usageCount: number
  lastUsedAt?: Date
  expiresAt?: Date
  learnedAt: Date
  version: number
  createdAt: Date
  updatedAt: Date
}

Memory Synthesis:

Generates a comprehensive markdown document summarizing all approved memories for an agent, organized by category with statistics.

6. Connectors - External Services Integration

Connectors enable DEVS to integrate with external services, importing content into the Knowledge Base. See docs/CONNECTORS.md for full documentation.

Connector Categories:

Category	Auth Method	Examples	Status
Apps	OAuth 2.0 PKCE	Google Drive, Gmail, Calendar, Notion	✅ Implemented
APIs	API Key / Bearer	Custom REST/GraphQL endpoints	🔜 Planned
MCPs	MCP Protocol	Local/Remote MCP servers	🔜 Planned

Implemented App Connectors:

Google Drive - Import files and documents with delta sync
Gmail - Import emails with label filtering
Google Calendar - Import events as markdown documents
Notion - Import pages and databases with block-to-markdown conversion

Key Features:

OAuth 2.0 with PKCE for secure browser-based authentication
Delta sync with cursor-based change tracking
Content normalization to KnowledgeItem format
Background sync via Service Worker
Encrypted token storage using Web Crypto API

Architecture:

src/features/connectors/
├── oauth-gateway.ts        # OAuth 2.0 PKCE flow
├── provider-registry.ts    # Lazy-loaded provider management
├── sync-engine.ts          # Delta sync orchestration
├── normalizer.ts           # Content → KnowledgeItem
├── providers/apps/         # Provider implementations
├── components/             # UI components
└── hooks/                  # React hooks

7. Local Backup - Bidirectional File Sync

Local Backup provides automatic, bidirectional synchronization between DEVS's IndexedDB database and a local file system folder. See docs/LOCAL-BACKUP.md for full documentation.

Key Features:

Bidirectional Sync - Changes flow both ways—edit files locally or in DEVS
Live Sync on Changes - Automatic backup when data changes (2-second debounce)
Human-Readable Format - Markdown files with YAML frontmatter
Full Database Export - Complete JSON backup for disaster recovery
Privacy-First - All data stays on your device—no cloud services

Supported Entity Types:

Entity	Directory	Format
Agents	`agents/`	`.agent.md`
Conversations	`conversations/`	`.md`
Memories	`memories/{agentId}/`	`.md`
Knowledge	`knowledge/{path}/`	`.md` + file
Tasks	`tasks/`	`.md`

Use Cases:

Version control integration (Git repositories)
External editing with favorite text editors
Cross-device sync via cloud storage folders
Disaster recovery and data portability

8. Dynamic Team Formation (Future)

Mimics human organizational structures and dynamics
Agents with defined roles, responsibilities, and communication patterns
Hierarchical and flat organization structures
Inter-agent collaboration protocols

9. Web Grounding (Future)

Agents can interact with web content
Sandboxed iframe execution for safety
Content extraction and parsing
API integrations through browser-safe methods

10. P2P Collaboration (Future)

WebRTC-based peer-to-peer connections
Distributed agent orchestration across multiple users
CRDT (Conflict-free Replicated Data Types) for shared state
Privacy-preserving collaboration protocols

11. Global Search

The Global Search feature provides a unified, fast search experience across all DEVS entities. See docs/SEARCH.md for full documentation.

Key Features:

Keyboard shortcut access (Cmd/Ctrl + K)
Parallel search across agents, conversations, tasks, files, memories, and more
Score-based relevance ranking
Grouped results by category
Recent searches and quick navigation

12. Meeting Bot - Google Meet Integration

DEVS enables AI agents to join Google Meet meetings as real participants. See docs/MEET-BOT.md for full documentation.

Key Features:

Join Google Meet meetings as authenticated participants
Live transcription and note-taking
Interactive AI assistance during calls
Emoji reactions and chat responses
Meeting summarization

13. Traces - LLM Observability & Analytics

DEVS includes a comprehensive tracing system for monitoring, analyzing, and debugging all LLM interactions. See docs/TRACES.md for full documentation.

Key Features:

Request/response data capture for all LLM calls
Token usage and real-time cost tracking
Performance metrics (latency, P50, P95, P99 percentiles)
Error tracking and debugging
Analytics dashboard with charts

14. P2P Sync - Cross-Device Synchronization

DEVS uses a Yjs-first architecture where Yjs is the single source of truth for all application data. See docs/SYNC.md for full documentation.

Key Features:

Single source of truth: Yjs document contains all data
Offline-first with automatic IndexedDB persistence via y-indexeddb
Privacy-preserving (no central server sees user data)
CRDT-based automatic conflict resolution
WebSocket-based P2P sync with auto-reconnect
Reactive hooks (useLiveMap, useLiveValue) for instant UI updates
Automatic migration from legacy IndexedDB

15. Marketplace - Platform Extension System

The DEVS Marketplace transforms DEVS into an extensible platform, allowing the community to build and share custom extensions. All extensions are defined using YAML schemas with standardized hooks. See docs/MARKETPLACE.md for full documentation.

Extension Types:

Type	Description	Examples
Apps	Complete workflows combining agents and tools	Translation, Code Analysis, PR Review
Agents	Custom AI personas with specialized capabilities	Code Reviewer, Doc Writer, PR Analyst
Connectors	External service integrations	GitHub, Jira, Linear
Tools	Specific capabilities for agents	Web Search, Calculator, File Operations

Key Features:

Standardized YAML Schemas: Unified schema for all extension types
Discoverability: Searchable, categorized marketplace with ratings/reviews
Security: Sandboxed execution, permission systems
Interoperability: Extensions can compose and depend on each other
Low Barrier: Non-developers can create simple extensions via specialist agents

16. Extension Bridge - Sandboxed Extension API

Extensions run in sandboxed iframes and communicate with DEVS through a message-based API. The bridge script exposes the window.DEVS object for extensions. See docs/EXTENSION-BRIDGE.md for full documentation.

Available APIs:

API	Description
`DEVS.llm`	LLM chat and completion requests
`DEVS.ui`	Toast notifications, prompts, modals
`DEVS.t()`	Translation helper for i18n
Context	Theme, language, extension info

Key Features:

Secure message-based communication
Access to configured LLM providers
UI components integration (toasts, prompts)
Theme and language awareness
Full TypeScript type definitions

User Experience

Main Interface

Google-like simplicity - Single prompt area as the primary interface
Agent selector dropdown - "devs" as default orchestrator
Clean, focused design - Complexity hidden until needed

Default "devs" Orchestrator

Pre-configured development team with:

Product Manager Agent - Requirements analysis
Architect Agent - System design
Developer Agents - Implementation
QA Agent - Testing strategy
DevOps Agent - Deployment planning

Workflow Visualization

After prompt submission, users see:

Organization chart - Active agents and their relationships
Workflow timeline - Gantt chart of current progress
Agent chat panel - Real-time agent discussions
Human controls - Pause, intervene, approve actions

Technical Architecture

The whole architecture is described in ARCHITECTURE.md. @ARCHITECTURE.md

Core Principles

KISS (Keep It Simple, Stupid): Simple, straightforward solutions over complex ones
Composable: Independent, interchangeable components
Performant: Technologies known for speed and efficiency
Low-footprint: Minimal resource consumption
Test-Driven Development (TDD): Write failing tests first, then implement features

Frontend Stack

Bundler: Vite with static mode
TypeScript - For application logic
React components - Using the HeroUI React components library
Service Workers - For background processing and caching
Web Crypto API - For secure token management
IndexedDB - For local data storage
WebAssembly - For performance-critical tasks
Serving: Static site served using Caddy

Testing Framework

Test Runner: Vitest with jsdom environment
Testing Library: @testing-library/react
E2E Testing: Playwright for end-to-end browser testing
Test Structure: Unit tests for business logic, component tests for UI, integration tests for flows
TDD Approach: Write failing tests first, implement features to pass tests, refactor while maintaining green tests
Test Organization: Unit tests in src/test/, E2E tests in tests/e2e/
Coverage Tool: @vitest/coverage-v8 for code coverage reporting

Coverage Requirements

Category	Target	Priority
`src/lib/**` (utilities)	60%+	🔴 Critical
`src/stores/**` (state management)	60%+	🔴 Critical
`src/components/**`	30%+	🟡 Medium
`src/pages/**`	20%+	🟢 Low

TDD Mandate for New Features

All new features and important enhancements in src/lib/ and src/stores/ MUST follow TDD:

Write tests first - Create failing tests that describe the expected behavior
Implement minimally - Write just enough code to make tests pass
Refactor safely - Improve code quality while keeping tests green
Verify coverage - Run npm run test:coverage before committing

This ensures:

LLMs can safely enhance features without causing regressions
Critical business logic is always verified
Refactoring is safe and confident

Data Storage

Storage uses a Yjs-first architecture where Yjs is the single source of truth:

Primary storage: Yjs document with typed Y.Maps for all entities
Persistence: y-indexeddb automatically persists Yjs data to IndexedDB
P2P sync: y-websocket enables optional cross-device synchronization
Legacy support: Some browser-specific data (CryptoKeys, FileSystemHandles) remains in IndexedDB

Data Schema

Data types are defined in src/types/index.ts.

interface Agent {
  id: string
  slug: string // URL-friendly identifier, auto-generated from name, unique across all agents
  name: string
  icon?: IconName
  role: string
  instructions: string
  temperature?: number
  tags?: string[]
  tools?: Tool[]
  createdAt: Date
  updatedAt?: Date
  version?: string
}

interface Task {
  id: string
  workflowId: string
  title: string
  description: string
  complexity: 'simple' | 'complex'
  status: 'pending' | 'in_progress' | 'completed' | 'failed'
  assignedAgentId?: string
  parentTaskId?: string // Enables task hierarchies
  dependencies: string[] // Task dependency management
  requirements: Requirement[]
  artifacts: string[]
  steps: TaskStep[]
  estimatedPasses: number
  actualPasses: number
  createdAt: Date
  updatedAt: Date
  completedAt?: Date
  dueDate?: Date
}

interface Requirement {
  id: string
  type: 'functional' | 'non-functional' | 'constraint'
  description: string
  priority: 'must' | 'should' | 'could' | 'wont'
  source: 'explicit' | 'implicit' | 'inferred'
  validationStatus?: 'satisfied' | 'pending' | 'failed'
  evidence?: string[]
}

interface Workflow {
  id: string
  strategy: string
  status: 'pending' | 'running' | 'completed'
  checkpoints: Checkpoint[]
}

interface Conversation {
  id: string
  agentId: string
  participatingAgents: string[]
  workflowId: string
  timestamp: Date // Creation timestamp
  updatedAt: Date // Last modification timestamp, used for sorting
  messages: Message[]
  title?: string
  isPinned?: boolean
  summary?: string
  pinnedMessageIds?: string[]
}

interface KnowledgeItem {
  id: string
  name: string
  type: 'file' | 'folder'
  fileType?: 'document' | 'image' | 'text'
  content?: string
  contentHash?: string // SHA-256 hash for deduplication
  mimeType?: string
  size?: number
  path: string
  parentId?: string
  lastModified: Date
  createdAt: Date
  tags?: string[]
  description?: string
  syncSource?: 'manual' | 'filesystem_api'
  fileSystemHandle?: string
  watchId?: string
  lastSyncCheck?: Date
}

interface Artifact {
  id: string
  taskId: string
  agentId: string
  type: string
  description: string
  content: string // Base64 encoded or file reference
  status: 'pending' | 'completed'
  validates?: string[] // Requirement IDs this artifact validates
  dueDate?: Date
  createdAt: Date
}

interface Tool {
  id: string
  name: string
  description: string
  type: 'file' | 'web' | 'api' | 'shell' | 'custom'
  config: Record<string, any>
}

interface Checkpoint {
  id: string
  name: string
  status: 'pending' | 'completed'
  timestamp: Date
}

State Management Architecture

Yjs-First Stores:

All stores use Yjs as the single source of truth. Data is written directly to typed Y.Maps, and React hooks observe changes for instant reactivity.

// Store pattern: Direct Yjs writes
export function createAgent(data: AgentData): Agent {
  const agent = { ...data, id: nanoid(), createdAt: new Date() }
  agents.set(agent.id, agent) // Write to Yjs map
  return agent
}

// React hooks observe Yjs directly
export function useAgents(): Agent[] {
  return useLiveMap(agents).filter((a) => !a.deletedAt)
}

TaskStore (src/stores/taskStore.ts)
- Task lifecycle management via Yjs tasks map
- Requirement validation integration
- Step tracking and completion
AgentStore (src/stores/agentStore.ts)
- Agent discovery and caching via Yjs agents map
- Custom agent CRUD operations
- Team building support
ArtifactStore (src/stores/artifactStore.ts)
- Artifact lifecycle management via Yjs artifacts map
- Requirement linking and dependency tracking
- Versioning support
ConversationStore (src/stores/conversationStore.ts)
- Multi-agent conversation tracking via Yjs conversations map
- Message history management
- Title generation
ContextStore (src/stores/contextStore.ts)
- Context sharing between agents
- Expiration and cleanup
- Relevance filtering
UserStore (src/stores/userStore.ts)
- User preferences and settings
- Drawer state persistence
- Theme and language management
AgentMemoryStore (src/stores/agentMemoryStore.ts)
- Agent memory CRUD operations via Yjs memories map
- Learning event management
- Human review workflow
- Memory retrieval with relevance scoring
- Memory synthesis documents

Store Patterns:

Direct Yjs map writes (no IndexedDB round-trip)
Reactive hooks via useLiveMap and useLiveValue
Error handling with toast notifications
Automatic P2P sync when enabled

Knowledge Base System

Sophisticated knowledge management system for personal knowledge base maintenance:

File Management Features

Drag & Drop Upload - Intuitive file uploading with visual feedback
Folder Watching - Automatic synchronization with local directories using File System API
File Type Detection - Automatic classification based on extension and content
Deduplication - SHA-256 content hashing prevents duplicate storage
Real-time Sync - Background synchronization every 30 seconds with change detection

Supported File Types

Text Files: .txt, .md, .js, .ts, .jsx, .tsx, .css, .html, .xml, .csv, .yaml, .yml, .log
Image Files: .jpg, .jpeg, .png, .gif, .bmp, .webp, .svg, .ico, .tiff, .tif
Document Files: .pdf, .doc, .docx, .xls, .xlsx, .ppt, .pptx, .rtf, .epub

Automatic Synchronization

Change Detection - Monitors file modifications, additions, deletions
Background Processing - Non-blocking sync with progress feedback
Event System - Real-time notifications (sync_start, sync_complete, file_added, file_updated, file_deleted, sync_error)
Error Recovery - Graceful handling of permission errors
UI Feedback - Toast notifications and visual indicators

Data Privacy & Security

Browser-only Storage - All files stored locally in IndexedDB
No Server Upload - Files never leave the user's device
Permission-based Access - Uses File System API permissions
Content Hashing - SHA-256 hashing for integrity and deduplication

Security Features

Token encryption using SubtleCrypto API
No data ever leaves the browser
Sandboxed execution environments
Auto-lock after 15 minutes of inactivity
Optional biometric authentication

Performance Optimizations

Service Workers for background processing
WebAssembly for compute-intensive operations
Lazy loading of agent components
Cursor-based pagination for large datasets
Multi-layer caching for agents, contexts, and artifacts
Batch database operations
Automatic cleanup of expired contexts

Implementation Roadmap

Phase 1: Core MVP

Basic prompt interface with IndexedDB storage
LLM independence functionality for major providers
"devs" orchestrator with 3-5 core agents
Custom agent builder
Simple PDCA orchestration strategy
Real-time workflow visualization

Phase 2: Advanced Features

Additional orchestration strategies (DMAIC, A3, 8D)
Web grounding capabilities
Advanced human-in-the-loop controls
Performance analytics
Dynamic team formation

Phase 3: Ecosystem

P2P collaboration features
Marketplace for agents and strategies
Plugin system for community contributions
Multi-language support

Design Principles

Accessibility First - Anyone should be able to use it, regardless of technical expertise
Privacy by Design - User data never leaves their control
Progressive Disclosure - Simple by default, powerful when needed
Real-time Transparency - Users can always see what agents are doing
Fail Gracefully - Clear error messages and recovery options

Use Cases

Students - Research assistance, study planning, assignment help
Small Businesses - Operations management without large teams
Developers - Rapid prototyping and code generation
Researchers - Literature review, data analysis, hypothesis testing
Creative Professionals - Brainstorming, content creation, project planning

Development

Running Tests

# Run all unit tests once
npm run test:run

# Run tests in watch mode (recommended during development)
npm run test:watch

# Run tests with coverage report
npm run test:coverage

# Run E2E tests
npm run test:e2e

# Run E2E tests with UI (interactive debugging)
npm run test:e2e:ui

TDD Workflow (Mandatory for lib/ and stores/)

When adding or modifying code in src/lib/ or src/stores/:

Red: Write a failing test that describes the desired functionality
```
npm run test:watch  # Start test watcher
```
Green: Write the minimum code necessary to make the test pass
Refactor: Improve the code while keeping tests green
Verify: Check coverage before committing
```
npm run test:coverage
```

Example: Adding a new utility function

// 1. First, write the test in src/test/my-feature.test.ts
import { describe, it, expect } from 'vitest'
import { myNewFunction } from '@/lib/my-feature'

describe('myNewFunction', () => {
  it('should return expected result', () => {
    expect(myNewFunction('input')).toBe('expected output')
  })
})

// 2. Then implement in src/lib/my-feature.ts
export function myNewFunction(input: string): string {
  return 'expected output'
}

Development Commands

# Start development server
npm run dev

# Run linting
npm run lint

# Type checking
npm run typecheck

# Build for production
npm run build

Quality Metrics

The system tracks:

Requirement satisfaction rates
Task completion times
Agent utilization rates
Validation success rates
Refinement iteration counts
Repository stars and forks
Community contributions

Open Source Commitment

All code will be open source under the MIT license, with a focus on community-driven development. Contributions are welcome through GitHub pull requests.

Getting Started

Visit the web app (no installation required)
Configure your preferred LLM provider
Type your request in the prompt area
Watch as AI agents collaborate to solve your problem
Optional: Intervene or guide the process as needed

Future Vision

A world where AI augmentation isn't a luxury for the few, but a fundamental tool available to all—where anyone can leverage the power of AI teams to amplify their capabilities and achieve their goals.

Internationalization (i18n) Guidelines

When working with translation strings, apostrophes must be used with the "'" character instead of "'". This ensures consistent formatting across all localization files.

AI Agent Guidelines

Context7 MCP for Documentation

Always use Context7 MCP automatically when working on tasks that involve:

Library or framework API documentation
Code generation with external dependencies
Setup or configuration steps for tools/packages
Implementation patterns for React, Vite, Zustand, Playwright, HeroUI, or other project dependencies

This ensures accurate, up-to-date documentation is referenced without requiring explicit requests.

FilesExpand file tree

AGENTS.md

Latest commit

History

AGENTS.md

File metadata and controls

DEVS - AI Agent Orchestration Platform

Project Vision

Core Concept

Key Features

1. Browser-Native Architecture

2. AI Studio Features

3. LLM Provider Independence

4. Hyper Meta-Prompting System

5. Intelligent Multi-Agent Orchestration

Architecture Overview

Core Orchestration Components

Execution Strategies

Team Coordination Engine

Requirement Validation Engine

Error Handling & Retry Mechanisms

Context Sharing & Collaboration

Default DEVS Agent

Agent Memory System

6. Connectors - External Services Integration

7. Local Backup - Bidirectional File Sync

8. Dynamic Team Formation (Future)

9. Web Grounding (Future)

10. P2P Collaboration (Future)

11. Global Search

12. Meeting Bot - Google Meet Integration

13. Traces - LLM Observability & Analytics

14. P2P Sync - Cross-Device Synchronization

15. Marketplace - Platform Extension System

16. Extension Bridge - Sandboxed Extension API

User Experience

Main Interface

Default "devs" Orchestrator

Workflow Visualization

Technical Architecture

Core Principles

Frontend Stack

Testing Framework

Coverage Requirements

TDD Mandate for New Features

Data Storage

Data Schema

State Management Architecture

Knowledge Base System

File Management Features

Supported File Types

Automatic Synchronization

Data Privacy & Security

Security Features

Performance Optimizations

Implementation Roadmap

Phase 1: Core MVP

Phase 2: Advanced Features

Phase 3: Ecosystem

Design Principles

Use Cases

Development

Running Tests

TDD Workflow (Mandatory for lib/ and stores/)

Example: Adding a new utility function

Development Commands

Quality Metrics

Open Source Commitment

Getting Started

Future Vision

Internationalization (i18n) Guidelines

AI Agent Guidelines

Context7 MCP for Documentation