Inside Force AI's Multi-Agent Architecture: How Specialised AI Agents Work Together

When you ask Force AI a complex business question, you're not querying a single AI model. You're engaging a multi-agent system where specialised analysis agents collaborate, debate, and synthesize insights—all in seconds.

This post explains how it works.

The Problem with Single-Agent AI

Traditional AI assistants use a single model for everything. Ask about finance, marketing, or operations—the same generalist model attempts an answer. This creates problems:

• Expertise dilution: No model can be expert at everything
• Reasoning limits: Complex questions overwhelm single-pass processing
• Context loss: Important nuances get missed
• Inconsistent quality: Some domains better than others

Force AI takes a different approach: specialized agents working as a team.

The Specialised-Agent Architecture

Each analysis agent is specialised, with:

• Domain knowledge: Training and prompts focused on its specialty
• A consistent voice: Predictable perspective and communication style
• Memory: Context from previous interactions
• Tools: Access to specific data sources and calculations

The Analysis Domains

| Domain | Key Capabilities |

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

| Strategy | Synthesis, vision, decision-making |

| Finance | Financial modeling, cash flow, investment |

| Operations | Processes, efficiency, supply chain |

| Marketing | Market analysis, positioning, campaigns |

| Revenue | Pricing, sales strategy, revenue optimization |

| Technology | Tech strategy, architecture, innovation |

| People | Workforce planning, culture, talent |

| Security | Cybersecurity, data protection |

| Data & Analytics | Data strategy, business metrics, KPIs |

| Digital | Digital channels, online strategy |

| Customer Experience | Customer journey, satisfaction |

| Product | Product strategy, roadmaps |

| Communications | PR, internal comms |

| Knowledge | Learning, knowledge management |

LangGraph: The Orchestration Layer

We use LangGraph to coordinate agent interactions. LangGraph provides:

• State management: Shared context across agents
• Conditional routing: Dynamic agent selection based on query
• Cycles: Agents can consult each other iteratively
• Human-in-the-loop: Checkpoints for user intervention

Basic Workflow

┌─────────────────┐
│   User Query    │
└────────┬────────┘
│
▼
┌─────────────────┐
│ Query Classifier│
│  (Router Node)  │
└────────┬────────┘
│
┌────────────────┼────────────────┐
│                │                │
▼                ▼                ▼
┌──────────┐    ┌──────────┐    ┌──────────┐
│  Agent A │    │  Agent B │    │  Agent C │
└────┬─────┘    └────┬─────┘    └────┬─────┘
│               │               │
└───────────────┼───────────────┘
│
▼
┌─────────────────┐
│   Synthesizer   │
│ (Strategy Agent)│
└────────┬────────┘
│
▼
┌─────────────────┐
│  Final Response │
└─────────────────┘

Query Classification

When a question arrives, the router analyzes it to determine which agents should respond:

# Simplified routing logic
def classify_query(query: str) -> List[str]:
"""
Determine which analysis agents should handle this query.
Returns list of agent IDs.
"""

# Financial questions
if mentions_finance(query):
agents.append("finance")

# Marketing/market questions
if mentions_market(query):
agents.append("marketing")

# Operations questions
if mentions_operations(query):
agents.append("operations")

# Strategy questions always include the strategy agent
if is_strategic(query):
agents.append("strategy")

# The strategy agent always synthesizes the final response
if "strategy" not in agents:
agents.append("strategy")

return agents

Agent Collaboration Patterns

Agents don't just work in parallel—they can consult each other:

Pattern 1: Parallel Consultation

For questions touching multiple domains:

Query: "Should we expand to Germany?"

Parallel execution:
├── Marketing: Analyzes German market size, competition
├── Finance: Models financial requirements, ROI
└── Operations: Assesses operational complexity

All feed into the strategy agent for synthesis.

Pattern 2: Sequential Deepening

For questions requiring iterative analysis:

Query: "Our margins are declining. Why?"

Sequential flow:
Finance: Identifies margin decline is in Q4
Operations: Notes Q4 had supply chain disruptions
Marketing: Confirms no pricing pressure from market
Strategy: Synthesizes → Supply chain is root cause

Each agent builds on previous insights.

Pattern 3: Debate Resolution

When agents might disagree:

Query: "Should we raise prices or cut costs?"

Marketing: "Market research shows price elasticity is low—
we can raise prices 10% with minimal churn"

Finance: "Historical data shows churn doubled after
last price increase. Recommend cost focus."

Strategy (mediator): "Both perspectives valid. Recommend
segmented approach: raise prices for
enterprise, hold for SME while
optimizing costs in delivery."

State Management

LangGraph maintains shared state throughout the conversation:

class ConversationState(TypedDict):
# User input
query: str
context: str

# Agent outputs
agent_responses: Dict[str, AgentResponse]

# Collaboration tracking
agents_consulted: List[str]
agent_queries: List[AgentQuery]  # Inter-agent questions

# Synthesis
preliminary_synthesis: str
final_response: str
confidence: float

# Metadata
start_time: datetime
tokens_used: int

This state flows through the graph, accumulating insights from each agent.

The Synthesis Challenge

The hardest part isn't getting individual agent responses—it's combining them coherently. The strategy agent handles synthesis with special instructions:

• Identify agreements: Where do all agents align?
• Resolve contradictions: When agents disagree, explain the tension
• Prioritize actionability: Lead with what the user should do
• Show reasoning: Make the logic chain visible
• Acknowledge uncertainty: Don't oversell confidence

Synthesis Example

Individual Responses:

• Finance: "Cash reserves support 18 months runway. Expansion is financially feasible."
• Marketing: "German market is saturated. UK has 3x growth potential remaining."
• Operations: "German operations require new supply chain—6 month setup minimum."
• Revenue: "Current sales team lacks German language skills."

Synthesis:

Summary: German expansion is financially feasible but strategically premature.

>

Key Findings:

- ✅ Financial capacity exists (18 months runway)

- ⚠️ UK market has more accessible growth potential

- ⚠️ German entry requires 6+ months operational setup

- ❌ Current team lacks German market capabilities

>

Recommendation: Focus on UK growth for next 12 months. Begin German market research and language training as background activity. Revisit expansion decision when UK market share exceeds 15%.

>

Confidence: HIGH (all agents aligned on timing concerns)

Speed Optimization

Achieving fast response times for multi-agent workflows requires careful optimization:

Parallel Execution

Agents run simultaneously whenever possible:

# Parallel agent execution
async def run_agents(state: ConversationState, agents: List[str]):
tasks = [
run_agent(agent_id, state)
for agent_id in agents
]
results = await asyncio.gather(*tasks)
return results

Response Streaming

Users see responses as they're generated:

[Agent analysis in progress...]

Finance:    ████████░░ (80%)
Marketing:  ██████████ (100%) ✓
Operations: ███████░░░ (70%)

Synthesizing response...

Caching and Context

Frequently accessed data is cached:

• Company profile (loaded once per session)
• Industry benchmarks (refreshed daily)
• Previous Q&A pairs (for consistency)

Model Selection

Not every agent needs the most powerful model:

| Task | Model | Reason |

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

| Query classification | Flash | Speed critical |

| Domain analysis | Flash | Good enough accuracy |

| Complex reasoning | Pro | When depth matters |

| Synthesis | Flash | Speed + quality balance |

Memory and Learning

Force AI maintains both short-term and long-term memory:

Short-Term (Session)

• Current conversation history
• User corrections and preferences
• Context documents uploaded

Long-Term (Persistent)

• Company profile and preferences
• Historical Q&A patterns
• User feedback on responses

Continuous Improvement

We track response quality through:

• User feedback (👍/👎)
• Follow-up questions (indicates incomplete answer)
• Time spent reading (engagement signal)
• Explicit corrections

This data improves routing, agent prompts, and synthesis quality over time.

The Technology Stack

Core Components

| Component | Technology | Purpose |

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

| Orchestration | LangGraph 0.2.x | Agent coordination |

| Primary LLM | Google Gemini 2.5 Flash | Fast, capable responses |

| Fallback LLM | Anthropic Claude | Complex reasoning |

| Backend | FastAPI | API layer |

| State Store | Redis | Session state |

| Vector Store | ChromaDB | Knowledge retrieval |

Why Gemini 2.5 Flash?

We chose Gemini Flash for several reasons:

• Speed: Fastest inference for acceptable quality
• Context Window: 1M tokens for document analysis
• Cost: Low per-query cost makes daily use feasible
• Reasoning: Chain-of-thought visible in outputs

LangGraph Advantages

LangGraph (from LangChain) provides:

• Native async: Essential for parallel agents
• Graph visualization: Debug and explain workflows
• Checkpointing: Resume interrupted conversations
• Human-in-the-loop: Approval gates when needed

What We Learned

Building a multi-agent system taught us:

1. Specialization Beats Generalization

A focused agent with strong prompts outperforms a general agent every time. The finance agent with finance-specific instructions beats a generalist model on finance questions—even when the generalist is more powerful.

2. Synthesis is the Hard Part

Getting individual agents to perform well is relatively easy. Combining their outputs coherently is surprisingly difficult. We went through 17 iterations of our synthesis prompts.

3. Speed Matters More Than You Think

Users abandon queries that take more than 10 seconds. Parallel execution and streaming responses aren't nice-to-haves—they're essential.

4. Transparency Builds Trust

Showing which agents contributed to a response, and their individual reasoning, dramatically increased user trust in our early testing.

5. Feedback Loops Are Essential

Agents improve when you can measure their performance. We track success by agent, continuously identifying underperformers and iterating on their prompts.

What's Next

We're continuing to evolve the multi-agent architecture:

• Proactive agents: Analysis that surfaces insights without being asked
• Custom agents: Let enterprises add their own specialized agents
• Agent memory: Longer-term learning about company context
• Faster synthesis: Always chasing lower response times

---

Try It Yourself

Experience the AI strategy advisor at executiveforceai.com. The free tier includes 50 queries—enough to see the multi-agent magic in action.

---

Have technical questions about our architecture? Reach out at tech@executiveforceai.com