inframagics-design

Core Analogy

Inframagics mirrors the Claude Code experience for non-technical users:

| Claude Code | Inframagics |

|-------------|-------------|

| Terminal/CLI interface | Chat interface (Genspark-style) |

| User mode: Write code, commit | User mode: Submit requests, execute tasks |

| Admin mode: Create rules/MCP/skills | Admin mode: Create policies, SOPs, workflows |

| System evolves as you use it | System learns and improves over time |

Key difference: Inframagics is for people extremely uncomfortable with terminal/CLI.

Unified Interface, Role-Based AI

Same UI for all roles — Only the AI behavior changes:

| Role | AI Focus |

|------|----------|

| Admin | Policies, SOPs, settings, system configuration |

| User | Clarify request → Reason → Retrieve policies → Execute |

| Manager | Team oversight, approvals, delegation |

Self-Improving System

```

User friction → Admin creates policy → System improves → Future users benefit

```

This virtuous cycle is why Inframagics replaces the ops team, not just the tools.

---

| Role | Scale | Priority | Description |

|------|-------|----------|-------------|

| Admin | 10+ | P0/MVP | System owner, policy creator, approver |

| User | 10+ | P0/MVP | Request submitter, information seeker |

| Manager | 30+ | P1 | Team approver, delegator |

| Policy Owner | 100+ | P2 | Domain specialist |

| External | 300+ | P3 | Vendors, auditors |

MVP Focus: Admin + User, Finance (Expenses) only

---

Traditional Enterprise Model

```

Policy Makers → SOPs → Operational Staff → ERP/CRM → End Users

↓ ↓ ↓ ↓

Executives Documents Humans Software

define interpret execute records

```

Problems:

• SI fees: 6-7 figures for setup
• Policy changes: Weeks + SI involvement
• Ops team: 10-50 people interpreting rules
• Knowledge: Scattered across systems/heads

Inframagics Model

```

Policy Makers → Policies (in system) → AI Agent → End Users

↓ ↓ ↓

Executives Natural Executes

define in language, policies,

natural instant handles

language changes requests

```

Value:

• Setup: Self-service, 4-5 figures max
• Policy changes: Instant, no SI needed
• Ops team: Eliminated or minimal
• Knowledge: Organized, retrievable, contextual

---

Definition: Next unicorns — fast-growing startups that will need enterprise systems but don't want enterprise baggage.

Baby-Corn Characteristics

| Trait | Implication for Design |

|-------|------------------------|

| Growing fast | System must scale without reimplementation |

| Lean teams | No dedicated ops staff; everyone wears hats |

| Tech-savvy founders | Expect modern UX, no tolerance for legacy |

| Cash-conscious | Won't pay 6-figure SI fees |

| Agile culture | Need instant policy changes, not IT tickets |

| AI-native thinking | Expect AI to do the work, not assist |

NOT Our Target

• Legacy enterprises: Have sunk costs in SAP/Oracle, change-averse
• SMBs with no growth: Don't need policies, just basic tools
• Industries with rigid compliance: Healthcare, banking (initially)

Design Implication

Every feature should pass the "baby-corn test":

> "Would a 50-person startup with no ops team be able to use this without training or consultants?"

---

Capability 1: Policies & SOPs

What it replaces: Policy manuals, training documents, approval workflows configured by SIs

How it works:

```

Policy Maker says: "Purchases over $5000 need VP approval"

↓

System interprets + confirms understanding

↓

Policy active immediately, enforced by agent

↓

End user makes request → Agent applies policy

```

Key Design Principles:

1. Natural language in, structured execution out

- Input: "New vendors need finance approval"

- System: Parses, confirms, stores structured rule

- Never ask policy maker to fill forms

1. Confirmation before activation

- Show: "I understood this as: [structured interpretation]"

- Allow: Edit, adjust, test before going live

- Never: Silently activate possibly wrong interpretation

1. Instant changes, zero downtime

- Policy maker edits policy → Live immediately

- No IT ticket, no deployment, no SI call

1. Conflict detection

- When new policy conflicts with existing, surface it

- "This overlaps with [other policy]. How should I prioritize?"

1. Execution visibility

- Every policy application logged

- Policy maker can see: "This policy triggered 47 times this week"

Interface Pattern:

```

┌─────────────────────────────────────────────────────────┐

│ Define a policy... 🎤 │

│ ───────────────────────────────────────────────────── │

│ "Expenses over $500 require manager approval" │

└─────────────────────────────────────────────────────────┘

↓

┌─────────────────────────────────────────────────────────┐

│ I'll create this policy: │

│ │

│ Type: APPROVAL │

│ Trigger: expense.amount > 500 │

│ Action: Require approval from reporting_manager │

│ │

│ [Edit] [Test with example] [Activate] │

└─────────────────────────────────────────────────────────┘

```

---

Capability 2: Request Handling

What it replaces: Ops team that receives requests, interprets policies, executes tasks

How it works:

```

End user says: "I need to expense this $800 dinner with client"

↓

Agent checks policies: "Expenses > $500 need approval"

↓

Agent: "I'll submit this for manager approval.

Adding it to Sarah's queue. You'll be notified."

↓

Sarah approves → Agent completes expense submission

```

Key Design Principles:

1. Intent-based, not form-based

- User states what they want

- Agent figures out how to do it

- Never: "Please fill out form XYZ"

1. Policy application is transparent

- "This needs approval because [policy X]"

- User understands why, not just blocked

1. Agent handles mechanics, human handles judgment

- Agent: Data entry, routing, notifications

- Human: Approval decisions, exceptions

1. Proactive, not reactive

- Agent: "Your expense report has 3 items waiting. Should I submit?"

- Not: User must remember to check status

1. Graceful escalation

- If agent can't handle, escalate to human clearly

- "I'm not sure how to handle [X]. Let me connect you with [person]."

Interface Pattern:

```

┌─────────────────────────────────────────────────────────┐

│ What do you need? 🎤 │

│ ───────────────────────────────────────────────────── │

│ "Bill Acme Corp $15,000 for the consulting project" │

└─────────────────────────────────────────────────────────┘

↓

┌─────────────────────────────────────────────────────────┐

│ 📋 Creating invoice for Acme Corp │

│ │

│ Amount: $15,000 │

│ Description: Consulting project │

│ Due: Net 30 (per your policy for this client) │

│ │

│ ⚠️ This exceeds $10,000 - requires Finance approval │

│ I'll route to CFO after you confirm. │

│ │

│ [Confirm & Route] [Edit details] [Cancel] │

└─────────────────────────────────────────────────────────┘

```

---

Capability 3: Knowledge Organization & Retrieval

What it replaces: Confluence, SharePoint, Notion sprawl; tribal knowledge in people's heads

How it works:

```

User asks: "What's our policy on remote work?"

↓

Agent searches knowledge base

↓

Agent: "Remote work policy (updated March 2024):

- 3 days/week in office minimum

- Core hours 10am-3pm

- Equipment stipend $500/year

Want me to show the full policy or help with something specific?"

```

Key Design Principles:

1. Conversational retrieval, not search results

- Don't show: 47 matching documents

- Show: The answer, with source citation

1. Knowledge capture from policies

- Policies automatically become queryable knowledge

- "What's the approval limit for travel?" → Finds from policy

1. Context-aware answers

- Agent knows who's asking

- Different answer for manager vs. new hire

1. Living documentation

- When policy changes, knowledge updates automatically

- No stale documentation problem

1. Capture tribal knowledge

- "How do we usually handle X?" can be saved as knowledge

- Turn one-off answers into reusable knowledge

Interface Pattern:

```

┌─────────────────────────────────────────────────────────┐

│ Ask anything... 🎤 │

│ ───────────────────────────────────────────────────── │

│ "How do I get reimbursed for conference travel?" │

└─────────────────────────────────────────────────────────┘

↓

┌─────────────────────────────────────────────────────────┐

│ For conference travel reimbursement: │

│ │

│ 1. Submit expense within 30 days of travel │

│ 2. Include receipts for anything over $25 │

│ 3. Per diem is $75/day for meals (no receipts needed) │

│ 4. Pre-approval required for international travel │

│ │

│ 📎 Source: Travel Policy (updated Nov 2024) │

│ │

│ Should I start an expense report for you? │

│ [Yes, start expense] [Show full policy] │

└─────────────────────────────────────────────────────────┘

```

---

Every feature must deliver on at least one:

✅ Eliminates SI Dependency

• [ ] Can policy maker configure without consultant?
• [ ] Is setup self-service?
• [ ] Can changes be made without IT ticket?

✅ Shrinks Operations Team

• [ ] Does this replace a human task?
• [ ] Is the agent doing work, not just assisting?
• [ ] Would a 50-person company NOT need an ops hire for this?

✅ Instant Policy Changes

• [ ] Can policy be changed in natural language?
• [ ] Is the change live immediately?
• [ ] Is there no deployment/release cycle?

✅ Knowledge Always Available

• [ ] Is information retrievable conversationally?
• [ ] Is there a single source of truth?
• [ ] Does it eliminate "ask Bob, he knows"?

Red flags (features that don't fit):

• "Requires initial setup workshop" ❌
• "Configure in admin settings" ❌
• "Integrate with your existing..." ❌ (v1 should be complete)
• "Training required for advanced features" ❌

---

Principle 1: AI Does, Human Confirms

```

Wrong: AI assists human doing work

Right: AI does work, human confirms/approves

Wrong: "Here's a draft invoice for you to review and edit"

Right: "I created the invoice. It's ready to send. [Send] [Edit first]"

```

Principle 2: Natural Language Everything

```

Wrong: Forms with fields

Right: Conversation that extracts what's needed

Wrong: "Select department: [dropdown]"

Right: "Who's this for?" → Agent figures out department

```

Principle 3: Policy Before Rejection

```

Wrong: User submits → Error: "Exceeds limit"

Right: User types intent → "This needs approval because [policy]" → User decides to proceed

User should never be surprised by a policy.

```

Principle 4: Zero Training for Basic Tasks

```

Wrong: "See documentation for how to submit expenses"

Right: "I need to expense lunch" → Agent handles everything

If a new employee can't accomplish basic tasks on day 1 without training, we've failed.

```

Principle 5: Instant Feedback Loop

```

Wrong: Policy maker defines → Wait days → See if it works

Right: Policy maker defines → Test immediately → See execution in real-time

```

Principle 6: Context is King

```

Wrong: Same interface for everyone

Right: Agent knows who you are, what you usually do, what's relevant

"Create invoice" for an AP clerk vs. CFO should feel different.

```

---

> Full specification: See Product/inframagics-roles-capabilities.md

Unified Chat Interface (All Roles)

Same UI structure for everyone — inspired by Genspark:

```

┌──────┬────────────────────────────────────────────────┐

│ + │ │

│ New │ Inframagics │

├──────┤ │

│ 🏠 │ ┌────────────────────────────────────────┐ │

│ Home │ │ Ask anything, request anything │ │

├──────┤ │ [📎] [🎤] [→] │ │

│ 💰 │ └────────────────────────────────────────┘ │

│ Fin │ │

├──────┤ Quick Actions / Recent items │

│ 👥 │ │

│ HR │ │

├──────┤ │

│ 📦 │ │

│ Proc │ │

├──────┤ │

│ 💻 │ │

│ IT │ │

├──────┤ │

│ ⚙️ │ │

│ Set │ │

└──────┴────────────────────────────────────────────────┘

```

Left sidebar = Business functions directory (collapsible icons)

Main area = Universal chat input + context-aware actions

Role-Based AI Behavior

Admin AI focuses on system configuration:

```

Admin: "Set expense limit to $500 for meals"

AI: ✓ Creating policy: Meal expenses capped at $500

✓ Applies to: All employees

→ Policy created. Notify employees?

```

User AI focuses on request execution:

```

User: "I had dinner with a client at Nobu, $450"

AI: ✓ Checking policy: Entertainment Expense Policy

✓ Amount $450 exceeds $200 → Manager approval required

→ Upload receipt? [📎 Attach]

```

Manager AI focuses on team oversight:

```

Manager: "What's pending?"

AI: ✓ 3 requests awaiting approval:

1. Sarah - $450 client dinner (over policy)

2. Mike - $89 supplies (auto-approvable)

→ Approve Mike's? [✓ Approve]

```

Key UX Requirements

• Single universal input (text + voice + attachments)
• Sidebar scopes context (clicking Finance focuses AI on Finance)
• Transparent reasoning (show policy lookups, routing decisions)
• Action buttons in responses (not forms)
• No separate admin/user URLs — role determines AI behavior

Anti-patterns to Avoid

• Form-based anything
• Module-based navigation (AP, AR, HR tabs)
• Separate admin/user interfaces
• Configuration tables and matrices
• Visual workflow builders
• Search results instead of answers

---

"Requires Consultant to Configure"

Symptom: Feature needs expert setup before use.

Fix: Natural language configuration with smart defaults.

"Ops Team Still Needed"

Symptom: Agent assists but human still does the work.

Fix: Agent does the work, human only approves/confirms.

"Knowledge Scattered"

Symptom: Information in docs, chat, email, people's heads.

Fix: All knowledge in Inframagics, conversationally retrievable.

"IT Ticket for Changes"

Symptom: Policy changes need admin/IT involvement.

Fix: Policy maker speaks change, it's live immediately.

"Training Required"

Symptom: Users need onboarding to use basic features.

Fix: Intent-based interface that anyone can use immediately.

"Enterprise UX Creep"

Symptom: Adding features that make sense for SAP but not baby-corns.

Fix: Apply baby-corn test: Would 50-person startup use this?

"Configuration Over Convention"

Symptom: Lots of settings, options, customization.

Fix: Smart defaults that work for 90% of cases.

---

vs. Traditional ERP (SAP, Oracle, NetSuite)

| Dimension | Traditional ERP | Inframagics |

|-----------|-----------------|-------------|

| Setup | 6-12 months, 6-7 figures | Self-service, days |

| Policy changes | IT project, weeks | Natural language, instant |

| User training | Weeks of formal training | Zero training needed |

| Ops team | Required (10-50 people) | Eliminated |

| Interface | Transaction codes, forms | Conversational |

Inframagics advantage: For baby-corns, we're the only option that doesn't require becoming an "enterprise" to use enterprise software.

vs. Modern SaaS (Monday, Notion, Asana)

| Dimension | Modern SaaS | Inframagics |

|-----------|-------------|-------------|

| Policy enforcement | Manual/honor system | Automatic, built-in |

| Approval workflows | Basic or bolt-on | Native, natural language |

| Knowledge retrieval | Search results | Conversational answers |

| Work execution | Human does it | Agent does it |

Inframagics advantage: SaaS tools organize work but don't do work. Inframagics agent actually executes.

vs. AI Assistants (Copilots, ChatGPT)

| Dimension | AI Assistants | Inframagics |

|-----------|---------------|-------------|

| Policy awareness | None (generic) | Built-in, enforced |

| System of record | External | Native |

| Action capability | Suggests | Executes |

| Knowledge scope | General | Company-specific |

Inframagics advantage: Generic copilots don't know your policies or have permission to act. Inframagics is the system AND the agent.

---

When reviewing Inframagics designs:

Value Delivery

• [ ] Does this eliminate SI dependency?
• [ ] Does this shrink the ops team need?
• [ ] Can policies be changed instantly?
• [ ] Is knowledge retrievable conversationally?

Baby-Corn Fit

• [ ] Would a 50-person startup use this?
• [ ] Is it usable without training?
• [ ] Is setup self-service?
• [ ] Does it avoid "enterprise bloat"?

AI-Native Design

• [ ] Is AI doing the work (not just assisting)?
• [ ] Is input natural language (not forms)?
• [ ] Are policies shown before rejection?
• [ ] Is context used to personalize?

Interface Quality

• [ ] Is there a single universal input?
• [ ] Are action options clear?
• [ ] Is status always visible?
• [ ] Can users accomplish goals in <30 seconds?

---

When deciding what to build:

Must Have (P0)

• Directly eliminates ops team need
• Enables instant policy changes
• Core to "agent does work" promise

Should Have (P1)

• Enhances core capabilities
• Improves baby-corn experience
• Requested by multiple prospects

Nice to Have (P2)

• Edge cases
• Power user features
• Future enterprise needs

Won't Build (v1)

• Requires SI to implement
• Only relevant for large enterprises
• Adds complexity without clear value
• "Because SAP has it"

---

Agent Effectiveness

• Tasks completed by agent: Target 80%+
• Tasks requiring human intervention: Target <20%
• Policy violations caught pre-submission: Target 95%+

User Adoption

• Time to first task completion: Target <5 min
• Tasks per user per week: Growing week-over-week
• Users needing support: Target <10%

Value Delivery

• Ops team size: Should be smaller than comparable companies
• Policy change time: Target <1 hour
• Setup time: Target <1 day for basic use

---

To baby-corn founders:

> "You'll never need a 50-person ops team. You'll never pay 7-figure SI fees. You'll never wait weeks for policy changes. Your AI agent handles operations. You focus on growth."

Every design decision should reinforce this promise.