Mudul is a protocol-first AI workflow workbench for turning unstructured real-world conversations and interactions into structured operational intelligence.
This repository is a protocol-first product prototype and workflow exploration, focused on how messy human input gets constrained, validated, persisted, and transformed into usable operational state.
The interesting part is not the AI summary itself.
The focus is the orchestration layer around AI: contracts, validation, memory, persistence, workflows, and UI systems that transform model output into usable operational software.
Mudul is not just "AI summarizes a call."
It is an AI-to-UI workflow architecture:
unstructured interaction → structured JSON → validated state → operational workflows → usable product UI
In practice that means:
- raw transcripts or notes come in
- AI analyzes them through schema-validated JSON contracts
- the output maps directly into UI components and workflows
- summaries become structured context
- action items become todo lists with priority, owner, and due dates
- objections become risk signals
- entities become structured records
- follow-ups become operational workflows and state
The current sales-call flow is the first demo vertical and proof of concept, but the same architecture can apply to:
- sales calls
- job interviews
- support calls
- consulting sessions
- research interviews
- internal meetings
- client discovery
- coaching and advisory sessions
- accepts a new transcript or notes input
- sends the interaction through a server-side AI analysis step
- validates the response against structured JSON contracts
- persists usable outputs such as summaries, objections, action items, entities, and sentiment
- surfaces the results in client-level and org-level dashboard views
- A user adds a transcript or messy conversation notes.
- The server routes the input into a mock or live AI provider flow.
- The response is normalized into a strict schema.
- Structured analysis is stored with interaction metadata.
- The validated output becomes product UI and workflow state.
The current demo focuses on sales-call analysis. It takes a transcript, runs structured AI analysis, and turns the output into client intelligence, account context, and org-level visibility.
That sales workflow is the first concrete implementation, not the limit of the architecture.
 |
 |
 |
 |
@mudul/core: domain types, repositories, seed/demo data, and shared analysis logic@mudul/protocol: AI contracts, prompt assets, JSON schemas, and validators@mudul/storage: persistence adapters and database setup@mudul/ui-headless: UI contracts intended to stay renderer-agnostic@mudul/ui-web: thin web renderers and UI composition helpersapps/web: the prototype web app, API routes, auth flow, and dashboard screens
See docs/architecture.md for layer boundaries and import direction.
Mudul treats AI as a structured subsystem rather than a chat surface:
- AI runs server-side only
- provider output is expected to match a schema
- malformed responses can be rejected or downgraded safely
- mock and fallback modes make the workflow testable without live credentials
This makes it easier to turn model output into persistent state and usable UI instead of manually reviewing free text after every interaction.
- The web app, transcript submission flow, and dashboard UI are implemented
- The repository supports both mock and live-provider analysis paths
- Seed/demo data is included for local exploration and demos
- The sales-call workflow is the current end-to-end proof of concept
- Some infrastructure paths still mix prototype shortcuts with production-oriented patterns
- Persistent multi-call memory is a direction, not a completed feature
pnpm install
pnpm --filter web dev
pnpm --filter web buildUse the root .env.example or the package-specific examples as templates for local setup.
Keep real credentials in local .env files only.