VibeFlow

## Inspiration

Companies rely on dozens of internal tools to manage sales, approvals, customer relationships, support tickets, and everyday operations. However, building these tools takes time, and most AI app builders start from scratch without understanding how a company actually works.

We wanted to solve this problem by asking a simple question: What if AI could build internal tools that already understand your company's people, policies, workflows, and past decisions?

That's how VibeFlow started. Our goal was to make internal tool development faster, smarter, and more accessible while ensuring that every generated application follows real business rules, remembers previous work, and adapts as the organization evolves.

What it does

VibeFlow is an AI-powered platform that turns natural language requests and visual workflows into fully functional, company-aware internal tools.

Instead of manually developing an application, users can type a command like /dealdesk or design a workflow on a canvas. VibeFlow then uses its multi-agent system to understand the request, retrieve company context, generate code, build the application, test it, and make it available through a secure preview.

What makes VibeFlow different is that it doesn't generate generic applications. It understands the company's knowledge graph, including employees, reporting structures, clients, contracts, approval policies, and previous decisions.

For example, if a sales representative requests a 27% discount, VibeFlow can build a deal approval tool that automatically routes the request to the CFO based on the company's current policy.

VibeFlow also includes:

Company-aware AI generation: Builds applications using actual business data, relationships, and rules.
Persistent AI memory: Remembers previous builds, successful solutions, errors, and policy updates.
Multi-agent orchestration: Specialized agents collaborate to plan, build, verify, and register applications.
Secure execution: Each generated application runs inside an isolated Daytona sandbox.
Automated testing: Applications are compiled and checked using a cloud browser before deployment.
Business simulations: AI personas simulate how employees and customers might interact with a tool to identify potential bottlenecks and risks.
Slack and Jira integration: Automatically creates deployment notifications and change records.

The result is a platform that helps organizations move from an idea to a working internal application without repeatedly explaining their business context.

How we built it

We built VibeFlow by combining AI agents, knowledge graphs, persistent memory, sandboxed development environments, and automated browser testing into one workflow.

Our architecture uses a multi-agent system in which specialized agents handle different stages of application development:

Router: Interprets user requests and retrieves relevant company information and previous solutions.
Planner: Converts the request into a technical specification grounded in business policies and organizational relationships.
Builder: Creates an isolated Daytona sandbox, provisions a database, and generates the application code.
Verifier: Builds the application, checks for errors, and repairs issues when necessary.
Curator: Registers completed tools, records execution history, and updates shared memory.

We used SurrealDB as the foundation for our company knowledge graph, application data, tool registry, and execution events. Graph relationships allow VibeFlow to understand connections between employees, departments, clients, contracts, and approval decisions.

For long-term intelligence, we integrated Agent Memory, which stores typed, time-aware facts, previous execution sessions, and successful development procedures. Instead of overwriting old information, VibeFlow tracks how facts and policies change over time, allowing agents to distinguish current rules from outdated ones.

We used Daytona to create isolated development environments for generated applications. Each sandbox receives its own embedded SurrealDB instance, and the AI-generated code is built using React, TypeScript, and Vite.

For verification, we integrated Anchor Browser, which launches applications in cloud Chromium, checks console errors, and captures screenshots. Build and runtime errors can be sent back through the repair process.

We also developed a lightweight MiroFish-inspired simulation system, where AI-generated personas interact with the application under real company policies to identify approval bottlenecks, operational risks, and possible improvements.

For AI reasoning, code generation, and semantic retrieval, we integrated NVIDIA NIM models, Nemotron embeddings, and OpenRouter fallbacks.

Finally, we connected the deployment workflow to Slack and Jira to create a traceable record of generated tools, testing results, and simulation findings.

Challenges we ran into

One of our biggest challenges was making AI-generated tools understand business context instead of producing generic applications. Company information is interconnected, and even a small policy change can affect several workflows. We addressed this by combining graph traversal with semantic retrieval and time-aware memory.

Another challenge was maintaining consistent memory across multiple AI agents. Each agent handles a different responsibility, but they all need access to the same organizational knowledge. We designed shared memory with separate agent scopes so that insights from one stage could improve future stages.

Running AI-generated code securely was also an important challenge. We needed applications to execute without exposing sensitive credentials or allowing unrestricted network access. Daytona's isolated sandboxes and embedded databases helped us separate generated tools from the main platform.

We also faced challenges with reliability and code generation quality. AI-generated code doesn't always compile or behave correctly on the first attempt. To improve reliability, we introduced automated build verification, browser-based testing, and repair loops.

Another technical challenge was handling limited resources and model performance. Sandbox memory limits affected how many applications could run simultaneously, while model response times influenced the overall generation process. We used prebuilt snapshots, model fallbacks, and reusable development procedures to improve the workflow.

Accomplishments that we're proud of

Our biggest accomplishment is building an end-to-end AI development workflow that goes beyond generating code. VibeFlow can understand company context, plan an application, generate code, provision its database, run build checks, test the application in a real browser, and register it for future use.

We're especially proud of:

Building a company-aware knowledge graph that connects employees, customers, contracts, opportunities, tickets, and approval rules.
Implementing time-aware memory that preserves historical facts and helps prevent outdated policies from influencing new applications.
Creating a multi-agent development pipeline with specialized responsibilities and shared memory.
Integrating secure Daytona sandboxes so generated applications run in isolated environments with their own databases.
Adding automated browser verification to identify runtime issues before tools are registered.
Developing AI-based business simulations that evaluate how generated tools might perform in realistic organizational scenarios.
Connecting Slack and Jira to document deployments, testing outcomes, and simulation insights.
Supporting reusable slash commands, allowing users to access generated applications without rebuilding everything from scratch.

Most importantly, we demonstrated how AI can move beyond one-time code generation toward a system that learns from previous builds and becomes more useful as company knowledge evolves.

What we learned

Building VibeFlow taught us that generating an application is only one part of solving a real business problem. The application also needs accurate context, reliable execution, secure infrastructure, and an understanding of how people will actually use it.

We learned how knowledge graphs and semantic memory complement each other. Graphs help represent relationships between people and business entities, while semantic memory helps AI agents retrieve relevant facts and experiences.

We also gained experience designing multi-agent workflows, managing shared memory, working with isolated cloud development environments, and automating software verification.

One of our biggest takeaways was the importance of preserving knowledge over time. Business policies and organizational structures constantly change, so AI systems need to understand not just what is true today, but also what changed and why.

Finally, we learned that AI-generated software needs verification and feedback. Combining automated testing, simulations, and reusable procedures makes the development process more practical than relying on code generation alone.

What's next for VibeFlow

Our vision is to make VibeFlow a platform where organizations can create, deploy, and continuously improve internal tools simply by describing what they need.

Our next steps include:

Expanding integrations: Turn visual workflow connectors into fully functional integrations with services such as Slack, Gmail, Jira, and other enterprise platforms.
Improving AI-generated applications: Enhance planning, code generation, and automated repair to produce more reliable and complex tools.
Smarter organizational memory: Improve how agents learn from previous builds, user feedback, policy changes, and application usage.
More advanced business simulations: Introduce richer scenarios, more realistic employee interactions, and stronger operational predictions.
Improved workflow builder: Allow users to create more complex applications using drag-and-drop components and natural language together.
Greater scalability: Optimize sandbox usage and infrastructure to support more users and generated applications.
Continuous tool improvement: Enable applications to evolve automatically when business requirements or company policies change, with appropriate verification and approval.

Our long-term goal is to make internal software development as simple as explaining a problem, while ensuring every application understands the business, follows its rules, and improves with experience.