Two Engineers, One Harness Workflow, 360 Hours: Building a Universal AI Personal Assistant
Itexus used an AI-first, harness-driven engineering approach to design and deliver Noxs 2.0 — an AI-native assistant that unifies Google Chat, Gmail, and meeting transcripts into one searchable memory and a self-organizing task board — for a Western Europe-based startup, using a lean two-person team instead of a full-stack delivery organization.
Key Success Metrics
Case Summary for Leaders
The client, a Western Europe-based startup, needed a way to stop losing critical information across the tools its teams used every day — Google Chat, Gmail, and meetings — where decisions and action items were made but never systematically captured or tracked.
Itexus delivered Noxs 2.0: an AI-native communication and productivity hub that continuously ingests conversations from all three channels, makes them instantly searchable through semantic (RAG) search, and uses Anthropic's Claude to turn conversations into tracked tasks on a Kanban board — with every task linked back to the exact message or meeting moment that created it.
The engagement was executed using an AI-first, harness-style delivery model: a two-person engineering team directed AI coding agents to implement the majority of the system — including the entire UI, generated directly from the client's design mockups — while engineers focused on architecture, technical direction, and quality control. The result was a fully working system delivered in 360 engineering hours, a fraction of the effort a conventional full-stack build would require, with a clear, validated architecture ready to scale to additional users.
| Industry | Startup |
| Segment | Enterprise productivity & communication tooling |
| Geography | Western Europe |
| Deployment Model | Self-hosted, containerized (Docker Compose), internet-accessible with authenticated access |
| Duration | ~4 months (360 engineering hours) |
| Team Size | 2 engineers |
| Delivery Model | AI-first / harness-style SDLC |
| Services | AI-first product engineering, AI agent/MCP integration |
| Technologies | Python, FastAPI, FastMCP, SQLAlchemy 2.0, PostgreSQL, Qdrant, React + Vite + Tailwind, Docker, Anthropic Claude API, OpenAI Embeddings API |
About the Client
The client is a startup based in Western Europe. Its teams — spanning engineering, product, and marketing — needed a way to manage a high volume of parallel projects and workstreams without losing track of decisions made across multiple communication channels. The client's product stakeholder initially defined the core need: a personal AI assistant capable of tracking commitments and context across the tools the team already relied on, with a second stakeholder from the client's marketing organization identified as an early adopter to validate the system beyond a single user.
The Challenge
Business Challenge
The client's teams made decisions and commitments across three+ channels (Google Chat, Gmail, meetings), with no single searchable source of truth.
Action items surfaced in conversation but were not consistently converted into tracked, assigned work — creating risk of dropped commitments across parallel projects.
The client wanted a lean, fast-to-deploy solution rather than a heavyweight enterprise platform build, requiring a delivery model that could move quickly without a large team.
Technical Challenge
Consolidating three structurally different data sources (Google Chat, Gmail, and Bluedot meeting transcripts) into one unified, queryable data model.
Giving an LLM (Claude) safe, well-scoped tool access to that data through MCP, rather than building a proprietary ML/LLM stack from scratch.
Directing AI coding agents to deliver production-quality code while maintaining tight control over codebase growth and architectural integrity.
Delivering the full scope — UI, backend, integrations, and AI orchestration — with a two-person team and no dedicated designer, QA engineer, DevOps engineer, or product owner.
Designing a multi-user architecture that could scale beyond the initial pilot user without compromising per-user data isolation.
Solution
Itexus applied a harness-style, AI-first delivery model: engineers set direction, defined architecture, and reviewed and validated all output, while AI agents implemented the majority of the system.
Key elements of the approach:
Design-to-code UI generation — engineers provided the client's design mockups directly to an AI coding agent, which generated the full production UI, built entirely through AI-agent implementation rather than manual frontend development.
Layered architecture with targeted human control — the system was structured into layers by criticality. The core data and business-logic layer (database schema, MCP tool design) was engineered and closely controlled by the Itexus team, while the REST API and integration layers were implemented by AI agents under engineering supervision.
Precision-scoped, iterative prompting — rather than issuing broad, open-ended build requests, engineers directed agents with narrow, well-defined instructions per module, validating each piece before moving to the next.
Session-based quality control — when agent output expanded beyond what was needed, engineers reset to a fresh session with a refined, single instruction, consistently producing smaller, cleaner, production-ready changes.
Zero proprietary AI/ML overhead — all conversational intelligence (reading messages, identifying tasks, answering context questions) is delegated to Anthropic's Claude via MCP tool-calling, keeping engineering investment focused entirely on data architecture and integration.
Use Cases Covered
| Use Case | Description |
|---|---|
| Decision retrieval | Surfaces decisions buried in chat history via natural-language query, returning the exact source message regardless of which tool it happened in |
| Conversation-to-task | Reads a planning discussion and creates prioritized tasks on the right project board, linked back to the source message |
| Contextual task lookup | Provides instant context on any task without manually searching chat logs |
| Meeting capture | Automatically captures meeting commitments from Bluedot transcripts, indexed alongside chat and email data |
| Triage inbox | Maintains an inbox for tasks from chats not yet linked to a specific project |
| Native agent access | Works natively from Claude Desktop via MCP — searching, syncing, and managing tasks as native tool calls, without a separate UI |
Problems Solved
Fragmented information across three channels — Consolidated into one searchable memory (Google Chat, Gmail, meetings)
Lost action items — Conversations flow directly into tracked, traceable tasks instead of disappearing into chat history
Cognitive overload from parallel workstreams — Addresses the client's core pain point of tracking multiple concurrent projects without becoming a bottleneck
AI-agent code-review bottlenecks — Solved through tightly scoped instructions and category-based change review, keeping agent-generated code fully auditable
Uncontrolled codebase growth from AI-generated code — Managed through disciplined session resets and refined, single-shot instructions
AI tooling cost efficiency — Achieved by tiering model selection to task complexity — premium models for complex problems, lightweight models for routine tasks
Solution Architecture
Noxs 2.0 is a containerized, service-oriented system built around the following components:
| Component | Role |
|---|---|
| Cron sync service | Periodically pulls new data from Google Chat, Gmail, and Bluedot; persists it to PostgreSQL; pushes new content through chunking/embedding into Qdrant |
| Board backend (FastAPI) | REST API for authentication, projects, tasks, and the in-task assistant; system of engagement for the web UI |
| MCP server (FastMCP) | Exposes search, sync, and task/project management capabilities as callable tools for LLM clients such as Claude Desktop |
| Frontend (React + Vite + Tailwind) | Kanban board UI, served behind Nginx alongside the API and MCP endpoints |
| PostgreSQL | System of record for chats, messages, users, projects, tasks, and assistant conversation history |
| Qdrant | Vector store powering semantic (RAG) search across all ingested content |
| Backup service | Scheduled pg_dump + rclone sync to cloud storage for data continuity |
The system was engineered in three logical layers, each assigned a deliberate level of AI-agent autonomy versus human control:
| Layer | Contents | Control Model |
|---|---|---|
| Core data / business logic | Database schema, MCP tool definitions | Designed and controlled directly by the Itexus engineering team |
| REST API | Structured data served to the UI | Implemented by AI agents under engineering direction and validation |
| MCP / agent-facing API | Tool-calling interface for Claude | Functionally parallel to the REST layer, built for autonomous agent consumption |
All conversational reasoning is performed by Anthropic Claude; Noxs 2.0's own infrastructure focuses entirely on data ingestion, storage, and secure tool exposure.
Integration Landscape
| Integration | Purpose | Status |
|---|---|---|
| Google Chat | Ingests space and DM messages via OAuth | Live |
| Gmail | Ingests email threads (domain-scoped) via OAuth | Live |
| Bluedot | Ingests meeting transcripts and notes | Live |
| OpenAI | Generates embeddings for semantic search | Live |
| Anthropic Claude | Powers the in-task assistant, task extraction, and MCP tool-calling | Live |
| Claude Desktop (MCP) | Exposes Noxs 2.0 as native tools inside any MCP-compatible LLM client | Live |
| Qdrant | Vector database backing semantic search | Live |
| PostgreSQL | System of record | Live |
| Google Cloud Storage (via rclone) | Offsite, scheduled database backups | Live |
| Additional chat/email/calendar providers | Broader enterprise chat coverage | Planned |
| Slack / Microsoft Teams | Broader enterprise chat coverage | Planned |
Technology Stack
| Layer | Technologies |
|---|---|
| Backend | Python, FastAPI (async REST API), FastMCP (MCP server), SQLAlchemy 2.0 (async ORM) + Alembic, PostgreSQL 15 + asyncpg, Qdrant + qdrant-client, OpenAI API (text-embedding-3-small), Anthropic Claude API, google-auth / google-api-python-client (Google Chat, Gmail), httpx (Bluedot), PyJWT + bcrypt |
| Frontend | React 18, Vite, Tailwind CSS, Google OAuth (@react-oauth/google), react-markdown / remark-gfm |
| Infrastructure | Docker Compose, Nginx, rclone |
| Engineering tooling | GitHub Copilot (backend/API, model tier matched to task complexity), agent-driven design-to-code workflow (UI generation), Anthropic Claude (runtime reasoning engine) |
Note: Frontend stack reflects the documented product architecture (React + Vite + Tailwind) as the authoritative technical record.
Delivery Approach
| Aspect | Detail |
|---|---|
| Team | 2 engineers |
| Effort | 360 engineering hours across ~4 months |
| Workflow | AI agents implemented the majority of the codebase under close engineering direction; engineers focused on architecture, task scoping, output validation, and quality control |
| Cost optimization | Model selection tiered to task complexity — lightweight models for routine tasks, premium models reserved for complex problems |
| Pacing | Structured to allow validation and refinement between iterations, ensuring a well-considered architecture rather than a rushed build |
| Efficiency benchmark | A traditional full-stack team (design, backend, frontend, QA, product owner) would typically require a minimum of three months for equivalent scope |
| Current stage | Successfully deployed for its initial pilot user, with a second user onboarding underway as part of a planned phased rollout, and a defined architecture roadmap for extending the platform to additional teams |
Results
| Result | Detail |
|---|---|
| Lean team delivery | Full system delivered with 2 engineers instead of the 5+ specialists a traditional build of this scope would require |
| Zero manual frontend development | Entire production UI generated by AI agents directly from client design mockups |
| Fast, complete delivery | 360 engineering hours produced a complete system: multi-source ingestion across three channels, semantic search, AI-driven task extraction, a full Kanban board, and native Claude Desktop/MCP integration |
| Cost efficiency | Highly efficient AI tooling costs achieved by matching model tier to task complexity throughout delivery |
| Scalable foundation | Validated, scalable architecture established, with per-user data isolation as a core design principle and a clear roadmap for onboarding additional users |
How This Expertise Can Help Your Team
The capabilities demonstrated in this project map directly to recurring challenges in AI adoption:
| Capability | What It Delivers |
|---|---|
| AI-first / Harness Development | Lean teams, AI-native tooling, and fast time-to-value on complex, multi-integration systems |
| AI Agent & MCP Integration | Exposing internal data and workflows as tool calls for LLM agents like Claude — letting foundation models handle reasoning while your systems handle data, security, and orchestration |
| Communication & Knowledge Unification | Consolidating scattered conversation data — chat, email, meetings — into a single searchable, actionable system that keeps distributed teams aligned |
FAQ
What does "harness methodology" mean in practice, and how automated was development?
Harness-style development means AI coding agents handle the majority of implementation, while engineers direct architecture, scope, and quality control. In this project, agents built the entire UI directly from design mockups and implemented the REST API layer, while engineers retained tight control over the core data model and business logic — ensuring both speed and production-grade reliability.
How does 360 hours compare to a traditional development timeline?
A traditional full-stack team — designer, backend engineer, frontend engineer, QA, and product owner — would typically need a minimum of three months to deliver equivalent scope. Itexus's two-person, AI-first team delivered the full system in 360 engineering hours, demonstrating the efficiency gain of harness-style delivery on a real production system.
If coding is typically a small share of engineering effort, where did the time savings come from?
The efficiency gain came primarily from AI agents taking over categories of work that would otherwise require dedicated specialists — most notably, the entire UI was generated from design mockups without any manual frontend development. This let a two-person team deliver scope that would normally require a much larger, more specialized team.
How is security and data access handled?
Noxs 2.0 is built on a per-user data isolation principle, modeled on how AI clients like Claude Desktop scope access locally to a single user's own connected accounts — ensuring one user's data and integrations remain isolated from others. The system is deployed with authenticated access, and the architecture includes a clear roadmap for further security hardening as the platform scales to additional users.
How does Noxs 2.0 scale to multiple users?
The platform's architecture was intentionally designed with multi-user scaling in mind from the outset. The initial deployment validated the core single-user experience with a live pilot user, and a second user is being onboarded as part of a planned, phased rollout — with per-user data isolation and task-assignment logic built into the roadmap for broader adoption.
What made this project a good fit for an AI-first harness approach?
The project combined well-defined integration targets (three established platforms: Google Chat, Gmail, Bluedot) with a clear, bounded initial use case (a personal productivity assistant) — the kind of scope where AI agents can implement the majority of the system quickly, while still benefiting from focused human oversight on core architecture and security design.
What lessons from this project apply to other teams considering AI-first development?
Three principles drove the project's efficiency: (1) keep the initial scope tightly defined and resist expanding it mid-build, since disciplined scope is what enables fast, high-quality delivery; (2) treat AI-agent oversight as an active engineering discipline — reviewing and constraining output is as important as directing it; (3) use session-based resets and precise, narrow instructions to keep AI-generated code clean and maintainable throughout the build.
Looking for an AI-First Engineering Partner?
We help startups and enterprises adopt AI-first, harness-style delivery, build lean engineering teams, and ship production AI systems fast — not just prototypes.