hervem_vs_langgraph.txt

 Hermes Agent: Feature Analysis & Enterprise Framework Comparison 2026

  ---
  What Kind of System Is Hermes?

  Before comparing frameworks, it's important to classify Hermes correctly. It is not the same category of thing as LangGraph or LangChain. Those are orchestration libraries — you build agent
   systems with them. Hermes is a fully assembled agentic runtime — it ships with the agent loop, 40+ tools, 19 messaging platform adapters, an execution environment abstraction layer, a
  skills marketplace, a context compression engine, multi-model routing, and an OpenAI-compatible API server, all integrated and configured out of the box.

  The right comparison is less "LangGraph vs Hermes" and more:

  - vs. LangGraph: Hermes trades compositional flexibility for operational completeness
  - vs. CrewAI: Both are higher-level, but Hermes has far more tools, channels, and built-in operational infrastructure
  - vs. building on Claude Agent SDK / OpenAI Agents SDK: Hermes is what you'd spend 6–12 months building if you started from those SDKs

  ---
  A. AI Provider Support

  Score: 9/10

  Hermes has the broadest provider coverage of any open-source agent framework in this comparison:

  ┌────────────────────┬─────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┐
  │        Tier        │                                                          Providers                                                          │
  ├────────────────────┼─────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┤
  │ First-class direct │ OpenAI, Anthropic, Google Gemini (AI Studio), Z.AI/GLM, Kimi/Moonshot, MiniMax, OpenCode Zen/Go, Hugging Face Inference API │
  ├────────────────────┼─────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┤
  │ Via OpenRouter     │ 200+ models (GPT-5, Claude, Gemini, Grok, DeepSeek, Mistral, Cohere, Meta Llama, Qwen, and all others)                      │
  ├────────────────────┼─────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┤
  │ Via Nous Portal    │ 400+ curated models                                                                                                         │
  ├────────────────────┼─────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┤
  │ Local/self-hosted  │ Ollama, llama.cpp, text-generation-webui, any base_url override                                                             │
  ├────────────────────┼─────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┤
  │ Voice/STT          │ Groq (Whisper), OpenAI Whisper, local faster-whisper                                                                        │
  ├────────────────────┼─────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┤
  │ TTS                │ Edge TTS (free), ElevenLabs, OpenAI TTS                                                                                     │
  ├────────────────────┼─────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┤
  │ Image gen          │ FAL.ai                                                                                                                      │
  └────────────────────┴─────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┘

  What actually makes this enterprise-relevant:

  - Ordered fallback chains: configure primary → fallback-1 → fallback-2. If OpenRouter returns 429, Hermes automatically retries on the next provider. This is built-in, not something you
  wire yourself.
  - Credential pool rotation: multiple API keys per provider, least_used rotation strategy, automatic failover on 401. Enterprises that run high-volume workloads need this. None of LangGraph,
   CrewAI, or the OpenAI/Claude SDKs ship this.
  - Context window-aware compression: auto-compresses at 85% of limit using a secondary model (default: Gemini Flash). Protects first and last turns, compresses the middle. 1,427-line
  trajectory_compressor.py is a serious implementation.
  - Structured output enforcement: GPT models have a GPT_TOOL_USE_GUIDANCE flag to force tool calls rather than text descriptions of actions — solving a real production problem where cheaper
  models default to describing rather than invoking.
  - Reasoning model support: extended thinking (Claude, Gemini, o1/o3) persisted across sessions with full context.

  Gap vs. PydanticAI: PydanticAI supports 25+ providers with a type-safe adapter per provider. Hermes goes deeper on each but uses a unified OpenAI-compatible call pattern
  (client.chat.completions.create()) — which works everywhere but loses provider-specific optimizations.

  ---
  B. Agentic Architecture

  Score: 7.5/10 — capable but not graph-native

  Hermes uses a synchronous ReAct loop:

  while api_call_count < max_iterations and budget_remaining > 0:
      response = client.chat.completions.create(...)
      if response.tool_calls:
          results = execute_tools(response.tool_calls)
          messages.append(results)
      else:
          return response.content

  This is deliberately simple. It avoids LangGraph's graph-definition boilerplate and the debugging opacity that comes with LCEL operator overloading. For most enterprise agent use cases
  (coding assistant, ops automation, customer support, data pipelines), this is sufficient and easier to reason about.

  Multi-agent orchestration via delegate_task spawns isolated child agents with independent context windows, iteration budgets, and tool state. ThreadPoolExecutor enables parallelism. The
  parent preserves its own context while children execute. This is the right pattern for hierarchical agentic tasks.

  Human-in-the-loop is natively integrated through the approval system, interactive clarification tool, and gateway-based approval routing (you can approve/deny a command from Telegram). This
   is more operationally integrated than LangGraph's interrupt() — which is more elegant but requires you to wire the front-end yourself.

  Where Hermes falls short architecturally vs. LangGraph: There is no explicit planning graph. You cannot define conditional branching logic as first-class code constructs, no cycle
  detection, no state machine with typed reducers. For complex multi-path workflows — say, a regulatory compliance pipeline that branches based on document classification — LangGraph's graph
  model is materially better suited. Hermes handles this through emergent LLM reasoning and subagents, which is less deterministic.

  Self-improvement is a genuine differentiator: after complex tasks, Hermes autonomously creates reusable skills. rl_cli.py integrates with Tinker-Atropos for RLHF on top of SWE-bench-style
  task environments. No other production agent framework ships with RL training infrastructure.

  ---
  C. Tool Ecosystem — Strongest in Class

  Score: 9.5/10

  Hermes ships with 40+ built-in tools covering categories that other frameworks either don't address or treat as exercises left to the developer:

  ┌───────────────────────┬──────────────────────────────────────────────────────────────────────────────┬────────────────────────────────────────────────────┐
  │       Category        │                                    Tools                                     │                  Enterprise Value                  │
  ├───────────────────────┼──────────────────────────────────────────────────────────────────────────────┼────────────────────────────────────────────────────┤
  │ Web & Research        │ DuckDuckGo, Exa, Firecrawl backends, web extraction                          │ Switchable backends, no single-provider dependency │
  ├───────────────────────┼──────────────────────────────────────────────────────────────────────────────┼────────────────────────────────────────────────────┤
  │ Terminal execution    │ Multi-backend (local/Docker/SSH/Modal/Daytona/Singularity)                   │ Isolation-aware, not just raw shell                │
  ├───────────────────────┼──────────────────────────────────────────────────────────────────────────────┼────────────────────────────────────────────────────┤
  │ File operations       │ Read, write, patch (fuzzy diff), search (regex), size limits                 │ Production-grade file handling                     │
  ├───────────────────────┼──────────────────────────────────────────────────────────────────────────────┼────────────────────────────────────────────────────┤
  │ Browser automation    │ 10+ Playwright-style actions + Browserbase cloud + CAPTCHA solving + stealth │ End-to-end web automation                          │
  ├───────────────────────┼──────────────────────────────────────────────────────────────────────────────┼────────────────────────────────────────────────────┤
  │ Vision & multimodal   │ Image analysis, image generation (FAL.ai), browser screenshots               │ Full multimodal pipeline                           │
  ├───────────────────────┼──────────────────────────────────────────────────────────────────────────────┼────────────────────────────────────────────────────┤
  │ Audio/voice           │ TTS (3 providers), STT (3 providers), voice memo transcription               │ Voice-enabled workflows                            │
  ├───────────────────────┼──────────────────────────────────────────────────────────────────────────────┼────────────────────────────────────────────────────┤
  │ Code execution        │ Sandboxed Python with env stripping                                          │ Safe code execution                                │
  ├───────────────────────┼──────────────────────────────────────────────────────────────────────────────┼────────────────────────────────────────────────────┤
  │ Memory & planning     │ Persistent memory, todo tracking, cross-session search (FTS5)                │ Institutional knowledge accumulation               │
  ├───────────────────────┼──────────────────────────────────────────────────────────────────────────────┼────────────────────────────────────────────────────┤
  │ Messaging             │ Cross-platform message send (19 channels)                                    │ Native communication fabric                        │
  ├───────────────────────┼──────────────────────────────────────────────────────────────────────────────┼────────────────────────────────────────────────────┤
  │ Scheduling            │ Cron job creation and management                                             │ Autonomous scheduled workflows                     │
  ├───────────────────────┼──────────────────────────────────────────────────────────────────────────────┼────────────────────────────────────────────────────┤
  │ Multi-model reasoning │ Mixture-of-agents consensus tool                                             │ Ensemble LLM decisions                             │
  ├───────────────────────┼──────────────────────────────────────────────────────────────────────────────┼────────────────────────────────────────────────────┤
  │ RL training           │ 9 RL training management tools                                               │ Model fine-tuning from within the agent            │
  ├───────────────────────┼──────────────────────────────────────────────────────────────────────────────┼────────────────────────────────────────────────────┤
  │ Home automation       │ 4 Home Assistant tools                                                       │ IoT integration                                    │
  ├───────────────────────┼──────────────────────────────────────────────────────────────────────────────┼────────────────────────────────────────────────────┤
  │ Delegation            │ Spawn and manage subagents                                                   │ Hierarchical orchestration                         │
  ├───────────────────────┼──────────────────────────────────────────────────────────────────────────────┼────────────────────────────────────────────────────┤
  │ MCP                   │ Full MCP server + 9 MCP management tools                                     │ Protocol-native integration                        │
  └───────────────────────┴──────────────────────────────────────────────────────────────────────────────┴────────────────────────────────────────────────────┘

  For comparison: LangGraph has ~5,000 community integrations through LangChain packages (breadth), but Hermes has deeper built-in coverage across the categories enterprises actually use
  (depth + operational integration).

  The skills system extends this further: 26 categories of skills installable from agentskills.io, with auto-creation of new skills from task experience. This is the closest thing in any
  open-source agent framework to a production-ready extensibility marketplace.

  ---
  D. Deployment & Integration

  Score: 9/10

  This is where Hermes genuinely has no peer among open-source frameworks:

  19 messaging platform adapters: Telegram, Discord, Slack, WhatsApp, Signal, Email (IMAP/SMTP), Matrix (E2E), Mattermost, HomeAssistant, DingTalk, Feishu/Lark, WeCom, SMS (Twilio), Webhook,
  OpenAI-compatible API, Open-WebUI, HTTP, and ACP (IDE). No other evaluated framework ships this.

  Execution backends: local, Docker (ALL-caps-drop hardened), SSH remote, Modal serverless, Daytona cloud, Singularity (HPC). Again — no other framework treats execution environment as
  first-class.

  OpenAI-compatible API server: expose Hermes as a drop-in replacement for OpenAI's chat completions endpoint. Any tool or integration that speaks OpenAI API works with Hermes. This is a
  significant integration story for enterprises with existing OpenAI-built tooling.

  MCP server: expose Hermes as an MCP server consumable by Claude Desktop, Cursor, VS Code, Zed. 9 tool surfaces including conversation management, message sending, approval management, event
   polling.

  ACP adapter: IDE embedding for VS Code, JetBrains, Zed via stdio transport.

  For enterprises thinking about omnichannel AI deployment — where the same agent capability is accessible from Slack, email, an internal API, and an IDE extension simultaneously — Hermes is
  the only open-source framework that ships this assembled.

  ---
  How Hermes Compares to Each Framework

  vs. LangGraph / LangChain

  ┌────────────────────────────────┬───────────────────────────────────────────────────────────────────┬──────────────────────────────────────────────────────────┐
  │           Dimension            │                             LangGraph                             │                          Hermes                          │
  ├────────────────────────────────┼───────────────────────────────────────────────────────────────────┼──────────────────────────────────────────────────────────┤
  │ Complex branching workflows    │ LangGraph wins — cyclic graphs, conditional edges, typed reducers │ ReAct loop, emergent via LLM reasoning                   │
  ├────────────────────────────────┼───────────────────────────────────────────────────────────────────┼──────────────────────────────────────────────────────────┤
  │ Time-travel debugging          │ LangGraph wins — checkpoint replay via LangSmith                  │ Trajectory JSONL, no replay UI                           │
  ├────────────────────────────────┼───────────────────────────────────────────────────────────────────┼──────────────────────────────────────────────────────────┤
  │ Observability platform         │ LangGraph wins — LangSmith is best-in-class                       │ Local logs + session search                              │
  ├────────────────────────────────┼───────────────────────────────────────────────────────────────────┼──────────────────────────────────────────────────────────┤
  │ Boilerplate for simple tasks   │ Hermes wins — zero graph definition needed                        │ Hermes wins                                              │
  ├────────────────────────────────┼───────────────────────────────────────────────────────────────────┼──────────────────────────────────────────────────────────┤
  │ Multi-platform gateway         │ Hermes wins — 19 channels built-in                                │ Not included                                             │
  ├────────────────────────────────┼───────────────────────────────────────────────────────────────────┼──────────────────────────────────────────────────────────┤
  │ Tool ecosystem                 │ Hermes wins — 40+ built-in, batteries-included                    │ LangChain community packages (5,000+, assembly required) │
  ├────────────────────────────────┼───────────────────────────────────────────────────────────────────┼──────────────────────────────────────────────────────────┤
  │ Multi-model routing + fallback │ Hermes wins — built-in with credential pool                       │ Requires custom wiring                                   │
  ├────────────────────────────────┼───────────────────────────────────────────────────────────────────┼──────────────────────────────────────────────────────────┤
  │ Self-improving skills          │ Hermes wins — unique                                              │ Not present                                              │
  ├────────────────────────────────┼───────────────────────────────────────────────────────────────────┼──────────────────────────────────────────────────────────┤
  │ Enterprise compliance tier     │ LangGraph wins — LangGraph Platform Enterprise                    │ None                                                     │
  ├────────────────────────────────┼───────────────────────────────────────────────────────────────────┼──────────────────────────────────────────────────────────┤
  │ Managed hosting                │ LangGraph wins — LangGraph Platform                               │ None                                                     │
  ├────────────────────────────────┼───────────────────────────────────────────────────────────────────┼──────────────────────────────────────────────────────────┤
  │ Production security CVEs       │ LangGraph had March 2026 CVEs (patched)                           │ Supply chain hardened (litellm removed)                  │
  ├────────────────────────────────┼───────────────────────────────────────────────────────────────────┼──────────────────────────────────────────────────────────┤
  │ Time to first working agent    │ Hermes wins                                                       │ More setup for simple workflows                          │
  └────────────────────────────────┴───────────────────────────────────────────────────────────────────┴──────────────────────────────────────────────────────────┘

  Bottom line on LangGraph: Use it when you need explicit, deterministic, auditable workflow graphs — financial processing, regulatory pipelines, complex conditional routing with human
  approval at specific nodes. The LangSmith observability is also meaningfully better than anything Hermes has today. But you pay a substantial setup tax, and the documented production issues
   (silent data corruption, infinite loops without circuit breakers, version coordination hell) are real.

  vs. CrewAI

  ┌─────────────────────────────┬──────────────────────────────────────────────────────────────────┬─────────────────────────────────────┐
  │          Dimension          │                              CrewAI                              │               Hermes                │
  ├─────────────────────────────┼──────────────────────────────────────────────────────────────────┼─────────────────────────────────────┤
  │ Time-to-working prototype   │ CrewAI wins — 20 lines, role-based metaphor                      │ More config surface                 │
  ├─────────────────────────────┼──────────────────────────────────────────────────────────────────┼─────────────────────────────────────┤
  │ Enterprise compliance (AMP) │ CrewAI wins — SOC2, SSO, RBAC, HIPAA at AMP tier                 │ None formal                         │
  ├─────────────────────────────┼──────────────────────────────────────────────────────────────────┼─────────────────────────────────────┤
  │ Visual editor               │ CrewAI wins — Studio                                             │ None                                │
  ├─────────────────────────────┼──────────────────────────────────────────────────────────────────┼─────────────────────────────────────┤
  │ Multi-platform channels     │ Hermes wins — 19 adapters                                        │ CrewAI has none built-in            │
  ├─────────────────────────────┼──────────────────────────────────────────────────────────────────┼─────────────────────────────────────┤
  │ Tool depth                  │ Hermes wins — 40+ built-in                                       │ Community library, more assembly    │
  ├─────────────────────────────┼──────────────────────────────────────────────────────────────────┼─────────────────────────────────────┤
  │ Built-in checkpointing      │ Neither — Hermes has session DB, CrewAI requires Temporal/custom │ Tie                                 │
  ├─────────────────────────────┼──────────────────────────────────────────────────────────────────┼─────────────────────────────────────┤
  │ Self-improving              │ Hermes wins                                                      │ Not present                         │
  ├─────────────────────────────┼──────────────────────────────────────────────────────────────────┼─────────────────────────────────────┤
  │ Execution environment       │ Hermes wins                                                      │ Not a first-class concern in CrewAI │
  ├─────────────────────────────┼──────────────────────────────────────────────────────────────────┼─────────────────────────────────────┤
  │ Provider support            │ Tie — both model-agnostic                                        │ Tie                                 │
  └─────────────────────────────┴──────────────────────────────────────────────────────────────────┴─────────────────────────────────────┘

  Bottom line on CrewAI: CrewAI AMP is the most credible enterprise-compliance offering in the open-source space right now. If your enterprise requires SOC2, SSO, SAML, and RBAC and you
  cannot operate your own infrastructure, CrewAI AMP is the path of least resistance. For teams that do have DevOps bandwidth, Hermes's operational capability exceeds CrewAI's significantly.

  vs. Microsoft/AWS/Google Ecosystem Frameworks

  If you're AWS-native and need FedRAMP, use Bedrock AgentCore — nothing else in this comparison gets you there. If you're Azure-native and need AAD + Office365 integration, use Semantic
  Kernel + Microsoft Agent Framework. If you're on GCP, Google ADK + Vertex AI Agent Engine is the natural fit.

  Hermes competes in the "cloud-agnostic, own your infrastructure" tier. It runs on any cloud, any VPS, any laptop — and that's a valid and important enterprise use case, especially for
  organizations with data residency requirements or those trying to avoid further cloud lock-in.

  vs. PydanticAI

  PydanticAI is the closest philosophical peer to Hermes in the code-first, type-safe, model-agnostic space. PydanticAI wins on type safety (catching errors at write time), provider breadth
  (25+), and architectural minimalism. Hermes wins on operational completeness (tools, channels, skills, environments, MCP server). For a new greenfield project where type-safety matters
  most, PydanticAI is worth serious consideration. For teams who want to deploy now with batteries included, Hermes has more.

  ---
  Enterprise Readiness Rating for Hermes

  Here is the honest scorecard:

  ┌──────────────────────────────────┬────────┬─────────────────────────────────────────────────────────────────────────────────┐
  │            Dimension             │ Score  │                                    Rationale                                    │
  ├──────────────────────────────────┼────────┼─────────────────────────────────────────────────────────────────────────────────┤
  │ AI provider breadth & resilience │ 9/10   │ Fallback chains, credential pools, 50+ models — best-in-class                   │
  ├──────────────────────────────────┼────────┼─────────────────────────────────────────────────────────────────────────────────┤
  │ Tool ecosystem completeness      │ 9/10   │ 40+ built-in, skills hub, MCP server/client — nothing else ships this assembled │
  ├──────────────────────────────────┼────────┼─────────────────────────────────────────────────────────────────────────────────┤
  │ Agentic orchestration capability │ 7/10   │ ReAct proven, subagents solid, no graph model — adequate for most cases         │
  ├──────────────────────────────────┼────────┼─────────────────────────────────────────────────────────────────────────────────┤
  │ Multi-platform deployment        │ 9.5/10 │ 19 channels, 6 execution backends, OpenAI API compat — uniquely complete        │
  ├──────────────────────────────────┼────────┼─────────────────────────────────────────────────────────────────────────────────┤
  │ Developer experience             │ 8.5/10 │ Rich CLI, deep config, skill/plugin extensibility, ~3K tests, good docs         │
  ├──────────────────────────────────┼────────┼─────────────────────────────────────────────────────────────────────────────────┤
  │ Security posture                 │ 7.5/10 │ Strong approval system + redaction, but no formal RBAC, no secrets encryption   │
  ├──────────────────────────────────┼────────┼─────────────────────────────────────────────────────────────────────────────────┤
  │ Observability                    │ 6/10   │ Local logs + session search only — no tracing product like LangSmith/Logfire    │
  ├──────────────────────────────────┼────────┼─────────────────────────────────────────────────────────────────────────────────┤
  │ Enterprise compliance            │ 4/10   │ No SOC2, no SSO/SAML, no formal RBAC, no managed audit export                   │
  ├──────────────────────────────────┼────────┼─────────────────────────────────────────────────────────────────────────────────┤
  │ Operational maturity             │ 8/10   │ v0.7, 3,420 commits, 168 PRs in latest release, actively hardened               │
  ├──────────────────────────────────┼────────┼─────────────────────────────────────────────────────────────────────────────────┤
  │ Vendor/lock-in risk              │ 9/10   │ MIT, model-agnostic, self-hosted, no managed service dependency                 │
  ├──────────────────────────────────┼────────┼─────────────────────────────────────────────────────────────────────────────────┤
  │ Self-improvement / RL            │ 9/10   │ Unique capability — no other production framework ships RL training             │
  └──────────────────────────────────┴────────┴─────────────────────────────────────────────────────────────────────────────────┘

  Overall Enterprise Readiness: 7.8/10

  ---
  My Recommendation: Which Would I Pick?

  The honest answer is that there is no single right choice — it depends on the enterprise profile. Here is the decision framework:

  Pick LangGraph + LangSmith if:

  You need deterministic, auditable workflow graphs — compliance automation, multi-step approval chains, regulatory processing. LangGraph's checkpointing + LangSmith's observability is the
  gold standard for this. Accept the boilerplate cost and the need to watch for their periodic CVEs.

  Pick CrewAI AMP if:

  You need the fastest path to SOC2-compliant, SSO-gated, RBAC-controlled deployment and you don't have DevOps bandwidth to operate your own infrastructure. CrewAI AMP is the only
  open-source-origin framework with a credible enterprise compliance tier out of the box right now.

  Pick Hermes if:

  You need an omnichannel agent platform — accessible via Slack, Telegram, email, IDE, and REST API simultaneously — with deep tool coverage, multi-model resilience, execution environment
  isolation, and the ability to self-improve over time. You have DevOps capacity to operate your own deployment. You want to avoid cloud vendor lock-in. This is the strongest "full-stack
  agentic platform" in the open-source space.

  Pick PydanticAI if:

  You are building a type-safe, code-first agent that will be maintained long-term by a Python engineering team, and you want the lowest possible lock-in at every layer. PydanticAI's
  compile-time safety + Temporal durable execution + 25-provider support is an excellent foundation.

  Pick AWS/Azure/GCP native if:

  You are already committed to one cloud and need compliance certifications without internal effort (FedRAMP → Bedrock, HIPAA → Azure, enterprise billing → all three).

  ---
  Should Enterprises Consider Hermes Over LangChain/LangGraph Today?

  Yes — with qualifications.

  The documented LangChain/LangGraph production issues are real (silent data corruption bugs, infinite loops without circuit breakers, version coordination overhead, March 2026 CVEs). For
  teams spending significant engineering time wrestling with LangGraph's abstraction layers for workloads that are fundamentally "run tools in a loop," Hermes's simpler execution model and
  substantially richer out-of-the-box capability is worth evaluating.

  Where Hermes is definitively better than LangGraph today:
  - Multi-channel deployment (19 platforms vs. zero)
  - Built-in tool coverage (40+ vs. community packages requiring assembly)
  - Multi-model fallback and credential pool rotation
  - Execution environment management (Docker/SSH/Modal)
  - Self-improvement via skills creation and RL
  - No framework abstraction-layer surprises
  - No CVEs reported

  Where LangGraph is still better:
  - Complex conditional workflow graphs with deterministic execution
  - LangSmith observability (replay, cost attribution, regression testing)
  - LangGraph Platform managed hosting
  - Formal enterprise compliance tier
  - Larger community and ecosystem of tutorials

  The one thing that would change this recommendation immediately: If Hermes adds a tracing/observability product and a formal enterprise compliance tier (SOC2, SSO, RBAC), the balance shifts
   decisively in Hermes's favor for most enterprise use cases. The Nous Research team has built the best-assembled open-source agentic runtime in 2026. The operational and compliance gap is
  the remaining barrier to displacing LangGraph in enterprise evaluations.