# My AI Agent Was Escalating Every Contract. One Decision Layer Fixed It 📑🤖📑🤖

> Source: <https://dev.to/sridhar_s_dfc5fa7b6b295f9/my-hermes-agent-couldnt-decide-which-contracts-needed-legal-review-one-planning-layer-fixed-it-11c3>
> Published: 2026-05-26 08:52:38+00:00

*This is a submission for the Hermes Agent Challenge: Build With Hermes Agent*

While experimenting with enterprise AI agents, I noticed a common problem:

Contract reviews are painfully manual.

Vendor agreements, NDAs, MSAs, and SOWs often require legal teams to manually inspect:

I wanted to see:

Can an AI agent intelligently decide what to review and when to escalate?

So I built an **Enterprise Contract Intelligence Agent powered by Hermes Agent**.

Instead of simply extracting text from contracts, the agent plans tasks, invokes tools, reasons through risks, and decides whether a contract actually requires legal review.

The interesting part?

My first version failed badly.

Hermes Agent was escalating almost every contract.

NDAs.

Vendor agreements.

Even low-risk contracts.

Technically the system worked.

Practically?

Completely unusable.

The issue turned out to be simple:

The agent lacked a confidence-based decision layer.

If a single clause looked risky, Hermes escalated immediately.

That created too many false positives.

So I redesigned the workflow.

Now Hermes Agent:

The result:

Hermes now behaves much more like a real enterprise analyst instead of a rule-based script.

Example output:

```
Contract Type:
Vendor Agreement

Risk Score:
7.2/10

Issues Found:
❌ Missing termination clause
❌ SLA definition unclear
⚠ Liability section weak

Confidence:
89%

Recommendation:
Escalate to Legal Review
```

For low-risk contracts:

```
Contract Type:
NDA

Risk Score:
2.1/10

Issues Found:
✅ Confidentiality present
✅ Termination clause present

Confidence:
94%

Recommendation:
Approved
Contract PDF
        ↓
Hermes Master Agent
        ↓
Task Planning
        ↓
Clause Extraction
        ↓
Risk Detection
        ↓
Confidence Scoring
        ↓
Compliance Check
        ↓
Final Recommendation
1. Read uploaded contract
2. Identify contract type
3. Extract important clauses
4. Detect missing sections
5. Evaluate business risk
6. Calculate confidence
7. Decide escalation
```

(Adding screenshots/video walkthrough soon 🚀)

Repository:

```
https://github.com/yourusername/hermes-contract-intelligence-agent
```

Example decision logic:

``` python
class ContractDecisionAgent:

    def should_escalate(
        self,
        risk_score,
        confidence
    ):

        if (
            risk_score > 0.7
            and confidence > 0.8
        ):

            return (
                "legal_review"
            )

        return (
            "approved"
        )
```

Hermes Agent sits at the center of the system.

Instead of hardcoding a workflow, I used Hermes for:

Hermes breaks the task into smaller reasoning steps.

Example:

```
Read contract
↓
Determine type
↓
Extract clauses
↓
Evaluate risk
↓
Decide escalation
```

Hermes invokes multiple tools dynamically:

```
parse_pdf()

extract_clauses()

risk_detector()

compliance_checker()

summary_generator()
```

Different contract types require different reasoning paths, and Hermes dynamically chooses what to do next.

The agent doesn't just summarize documents.

It reasons through:

This felt like a much more realistic enterprise use case for AI agents.

One big lesson from building this:

Agentic systems become useful only when they can decide

what to do next, not just generate text.

That’s where Hermes Agent really stood out for me.

Thanks for reading 🚀