-
-
RalphiIA unites ChatGPT, MCP, Codex, WhatsApp and local servers into one secure, coordinated, evidence-driven engineering team.
-
ChatGPT + RalphiIA MCP combined my subscription and credits to test flows, make decisions, and deliver verified Codex changes.
-
Multiple Codex sessions ran as coordinated workstreams, each with its own thread, repo, tests, commits, and closure evidence
-
RalphiIA’s WhatsApp interface turns natural-language prompts into safe, traceable tests across MCP, Codex, and our local servers.
-
Real Whatsapp interactions and notifications.
Inspiration
I run PC Doctor Ecuador while building new AI products, often as a solo founder with limited time, a finite budget, and no large engineering team. I am not Microsoft or Google. That is exactly the point.
Small businesses, startups, foundations, and non-technical founders can benefit enormously from AI, but the tools are fragmented. Conversations live in WhatsApp, code lives in IDEs, operational truth lives on servers, and important decisions disappear across separate chats. Most people do not need another chatbot. They need a dependable way to turn intent into coordinated, verifiable work.
OpenAI Build Week gave me the opportunity to test how much leverage one founder could create with a $100 Codex credit grant, GPT-5.6, ChatGPT, MCP, and two sovereign local servers. The result is RalphiIA FounderOS: an extensible operating system for founders that helps one person remember, operate, and build from anywhere.
FounderOS began as QuoteOps, a real workflow for understanding customer requests and preparing quotations. During Build Week, it grew into the platform underneath that workflow.
What it does
FounderOS is an agentic operations SaaS platform. It is not simply a CRM and it is not an unrestricted remote shell.
RalphiIA is the intelligent copilot inside FounderOS. It connects familiar interfaces such as ChatGPT and WhatsApp to governed business tools, persistent memory, Codex development tasks, and sovereign infrastructure through MCP.
The current project demonstrates two complete loops:
- AI Engineering Loop
A founder discusses a requirement with ChatGPT. Through the RalphiIA MCP connector, the conversation can inspect live project context and create a structured task with identity, ownership, priority, correlation, and evidence requirements.
Codex works on the appropriate repository in an isolated Git worktree, implements the change, runs tests, creates a commit, and reports the result. ChatGPT can then review evidence instead of trusting a confident completion message.
A verified execution crossed HTTP -> MCP -> Codex -> tests -> commit, recording the task, Codex thread, model, correlation, commit, timestamps, and result.
- Founder Operating Loop
From WhatsApp or the FounderOS interface, the founder can send text or voice while away from the office. RalphiIA authenticates the sender, follows the language of the current turn, processes supported media locally, remembers relevant context, and queries live services on two Linux servers.
Read-only checks return fresh verification time and evidence. Healthy services are not restarted. Sensitive actions stop at a human checkpoint bound to the same sender and conversation. When software work is required, the request can become a traceable Codex task.
The memory layer preserves useful operating context while distinguishing facts, opinions, hypotheses, emotions, intentions, decisions, and corrections. It does not present emotional observations as diagnoses.
QuoteOps remains the first business module built on FounderOS. Future modules can support customer operations, internal knowledge, infrastructure, marketing workflows, and organization-specific processes without rebuilding the control plane.
How we built it
We used:
- OpenAI Codex with GPT-5.6 Sol for architecture, repository analysis, implementation, debugging, security work, testing, and evidence-backed completion.
- ChatGPT as the founder-facing planning, decision, and supervisory interface.
- Model Context Protocol as the shared contract connecting conversations, agents, memory, business tools, and infrastructure.
- Python and MongoDB for task state, identity, memory, audit events, messages, and correlation.
- Evolution API and WhatsApp for mobile text, voice, images, guided actions, and delivery.
- Git worktrees, AppArmor, Bubblewrap, allowlists, timeouts, and secret-free runner environments for governed Codex execution.
- Whisper, FFmpeg, Tesseract, Ollama, and local visual models for local-first multimedia processing.
- Two sovereign Linux nodes providing primary/standby services, local models, monitoring, and recovery.
- Human-in-the-loop controls for production changes, service mutations, financial actions, and publishing.
The $100 credit grant was an accelerator, not the product. I used GPT-5.6 Sol at high speed for difficult architecture, integration, debugging, and security work. Mechanical multimedia and classification tasks remained local where practical. Parallel Codex tasks exchanged ownership, failures, commits, tests, and next actions, reducing the cost of repeatedly rebuilding context.
The work was intentionally split across multiple Codex sessions instead of one monolithic chat. Separate threads handled the OpenAI hackathon narrative, the QuoteOps P0 worker, the public hackathon surface, voice and image support, OpenWebUI-compatible authentication, Cloudflare/public access checks, and final evidence collection. Visible build evidence included Codex threads such as 019f6202-282e-7331-a276-e5f053337e7f, 019f620b-219b-7d83-aa3a-fa76e623d887, and 019f6b97-2984-7541-953e-d7dc814cdbfd, plus commits and test reports such as 63ce99bfc038 and 88/88 feed checks. The point is part of the product: FounderOS was built through the same distributed, evidence-driven operating model it exposes.
The project was built using the same operating model it now offers: Codex helped create, test, and repair the platform that subsequently invokes Codex as a governed development capability.
Challenges we ran into
The hardest challenge was not generating code. It was preventing plausible language from being mistaken for operational truth.
Early versions could report that a task had been delivered without proving that an agent accepted it. We introduced acknowledgements, ownership, heartbeats, locks, handoffs, correlation IDs, and evidence requirements.
Real infrastructure failures included sandbox restrictions, denied network access, an invalid refresh token on the standby server, mismatched local transcription ports, and inconsistent health sources.
Physical WhatsApp tests exposed unsupported CPU, RAM, and security claims. That produced a fundamental rule: operational status and causes must come from fresh structured evidence with timestamps. If telemetry is unavailable, the correct answer is "unknown."
We also learned that useful remote operation must not become an unrestricted WhatsApp shell. FounderOS separates observation from mutation, uses an allowlisted action catalog, binds approval to identity and conversation, and requires human confirmation for sensitive work.
Accomplishments that we're proud of
- Connected ChatGPT and Codex through a shared MCP task and evidence layer.
- Completed verified HTTP -> MCP -> Codex -> tests -> commit executions.
- Ran governed Codex capability across two sovereign servers.
- Used several Codex sessions as coordinated workstreams, each with its own thread, directory, context budget, commits, and closure evidence.
- Captured model, thread, task, correlation, commit, tests, timestamps, and results.
- Connected authenticated WhatsApp requests to live infrastructure and development work.
- Implemented local-first voice transcription, OCR, and visual context.
- Built persistent operating memory with provenance, confidence, privacy classes, and versioned corrections.
- Added same-sender approvals, allowlisted actions, replay protection, idempotency, rate limits, and audit trails.
- Reached 91/91 passing tests on each node for the latest memory and safe-operations stage, plus a passing post-deployment E2E fixture.
- Preserved failed runs and their fixes rather than rewriting the development story.
- Built a non-trivial system with limited resources from Ecuador that can become useful to other founders and organizations.
What we learned
Powerful models are only one part of a dependable agentic system.
A delivered message is not ownership. A confident response is not evidence. An animated dashboard is not real agent activity. Consequential transitions need identity, state, provenance, correlation, and a verifiable outcome.
GPT-5.6 Sol provided the most value by maintaining architectural coherence across difficult work, not merely by generating more code. The finite credits helped one founder move much faster, while local processing preserved capacity for the tasks where the advanced model mattered most.
Human approval is not opposed to autonomy. Carefully placed checkpoints make meaningful autonomy safe enough to use in a real company.
Most importantly, AI becomes accessible when it appears inside tools people already use, while tests, permissions, evidence, and rollback remain behind the scenes.
What's next for RalphiIA FounderOS
FounderOS will become a configurable SaaS platform for founders, small businesses, startups, foundations, and non-profits that do not have an internal AI engineering team.
Organizations will be able to start with a focused pain point: quotations, customer follow-up, internal knowledge, infrastructure monitoring, or another operational workflow, and grow by adding modules and agents over time. They will be able to operate the system themselves or use a supervised managed service.
Next steps include:
- Packaging the governed MCP control plane for repeatable installations.
- Publishing benchmarks for time saved, intervention count, latency, local-processing rate, and remote-model consumption.
- Deepening QuoteOps customer, email, quotation, and accounting workflows.
- Improving the evidence interface for non-technical users.
- Expanding role-based access for collaborators and organizations.
- Adding deterministic health and telemetry adapters.
- Providing a reproducible judge sandbox and installation path.
- Running beta deployments with real small organizations and documenting measurable outcomes.
The long-term goal is simple: give more people the operational leverage of an AI-enabled technical team, without requiring them to become AI engineers first.
Log in or sign up for Devpost to join the conversation.