telos

Estimated build cost - user decides to build or cancel
screenshot showing that the product is building
results shown to the user

Inspiration

We were inspired by a simple but frustrating truth: turning an idea into a real digital product still requires weeks of coordination, technical expertise, and multiple tools. Non-technical founders and creators often have powerful ideas but lack the execution bandwidth. Existing AI tools improve productivity by ~15%, but they still require constant supervision.

We wanted to build true agency — not “AI as assistant,” but AI as autonomous executor. Telos was born from the belief that one conversation should be enough to go from intent to delivery.

What it does

Telos converts a single natural-language instruction into a fully built, tested, and delivered digital project.

You describe your idea (by text or voice). Telos interviews you like a consultant, extracts structured requirements, generates a technical plan, splits it into PRDs, and deploys a swarm of specialized AI agents to build, review, and iterate — until the project is complete.

The output isn’t mockups. It’s real deliverables:

Functional websites
Campaign assets
Personalized emails
CRM integrations
Production-ready code

From intent to execution — autonomously.

How we built it

Telos is built around a multi-layer autonomous architecture:

ALI (Adaptive Language Interviewer) — a custom GPT-2 + LoRA model trained with SFT and PPO to extract structured requirements through dynamic interviews.
Plan Generator — uses Claude + Gemini via MCP to generate architecture, stack decisions, and risk analysis.
PRD Splitter — decomposes projects into ordered, self-contained work units.
Ralph (Self-Healing Build Loop) — a multi-agent execution engine that builds, reviews, fixes, and retries until approval or budget exhaustion.
Backend — FastAPI with SSE streaming.
Frontend — Next.js with a voice-first animated canvas interface.
RAG layer — ChromaDB + embeddings for context grounding.

We also built a full ML training pipeline with evolutionary optimization and Monte Carlo evaluation to maximize requirement coverage per conversation turn.

Challenges we ran into

Designing an interview system that balances coverage and conversation length.
Making agents self-heal instead of cascading failures.
Coordinating multiple AI models while keeping cost and latency manageable.
Preventing hallucinated architecture decisions during autonomous execution.
Building a real voice-first UX that feels alive, not gimmicky.

The hardest problem was trust: making sure the system produces real, verifiable deliverables — not just convincing text.

Accomplishments that we're proud of

Built a fully autonomous build loop that retries intelligently instead of failing silently.
Achieved 90%+ requirement coverage dynamically based on project complexity.
Delivered real production artifacts (HTML, emails, CRM integrations), not demos.
Implemented evolutionary reward optimization in the training pipeline.
Created a working end-to-end system during a hackathon timeframe.

Most importantly, we built something that actually ships.

What we learned

True autonomy requires structured decomposition — not bigger prompts.
AI agents need governance, gating, and review loops to be reliable.
Coverage metrics matter more than conversation length.
Execution quality improves dramatically when tasks are broken into explicit PRDs.
Agency is a systems problem, not just a model problem.