AIthena

AI-powered contract intelligence for SMEs — know what you owe, what’s next, and when to escalate.

Comment

Inspiration

AITHENA started from a simple but expensive SME problem:

One forgotten contract. One missed deadline. S$40,000 automatically renewed.

Small and medium-sized businesses may have dozens of customer agreements, supplier contracts, software subscriptions, NDAs, leases and distribution agreements sitting inside shared drives. The problem is not necessarily that the contracts are inaccessible — it is that nobody has time to continuously reread them and remember every renewal date, notice period, payment obligation or restriction.

We wanted to answer one practical question:

“What are we on the hook for, and what is coming up?”

That became AITHENA — an AI-powered contract intelligence platform designed to turn a folder of contracts into actionable information. Our focus was not simply summarising contracts, but helping SMEs know what they owe, what they need to act on next, and when a human should step in.

What it does

AITHENA transforms a portfolio of contracts into a single Contract Command Centre.

Users can upload multiple contracts in different formats, including PDFs, DOCX files and scanned documents. AITHENA then extracts important contractual information such as:

  • Parties
  • Contract term
  • Renewal mechanics
  • Notice periods
  • Payment obligations
  • Termination rights
  • Liability caps
  • Restrictions and exclusivity clauses

Instead of only displaying a renewal date, AITHENA calculates the contractual action-by date.

For example, if a S$40,000 software subscription renews on 15 November but requires 60 days' notice, AITHENA highlights that the SME actually needs to act by 15 September.

AITHENA also analyses contracts at the portfolio level. It can surface potential cross-contract conflicts, such as one distribution agreement granting exclusivity in Singapore while another agreement appoints a second distributor for the same territory.

But AITHENA is deliberately designed not to pretend that AI can make every legal judgement.

Every important finding is connected to supporting contract evidence, confidence is made visible, and uncertain or legally sensitive issues are routed to Human Review.

When escalation is needed, AITHENA can produce a structured lawyer-handoff brief containing the issue, relevant contracts, evidence and the specific question requiring legal judgement.

AI for scale. Humans for judgement.

How we built it

AITHENA uses a React and TypeScript frontend with Vite, supported by a Node.js backend.

Our processing pipeline follows the structure:

Contract ingestion → AI extraction → structured validation → evidence grounding → portfolio intelligence → action or escalation

We use an OpenRouter-powered LLM layer to interpret contract content and return structured contractual fields.

However, we intentionally do not rely on the language model for everything.

Where possible, deterministic backend logic handles tasks such as:

  • Calculating action-by dates
  • Building the 90-day calendar
  • Generating reminder schedules
  • Validating structured outputs
  • Applying trust and confidence states
  • Preventing uncertain information from feeding downstream calculations

The frontend then presents this information through dedicated views including:

  • Contract Command Centre
  • Contracts
  • Calendar
  • Financial Obligations
  • Restrictions
  • Potential Conflicts
  • Needs Human Review
  • Ask Your Contracts

For natural-language portfolio questions, the AI helps interpret what the user is asking, while the backend determines the factual result from structured portfolio data whenever possible.

This allows AITHENA to answer questions such as:

“Which contracts require action in the next 90 days?”

without simply asking an LLM to reason over dozens of entire contracts at once.

Trustworthy by design

One of our biggest design decisions was that uncertainty should change how the system behaves.

AITHENA separates information into trust states such as:

  • Verified — supported directly by strong contract evidence
  • Derived — calculated deterministically from trusted inputs
  • Human Review Required — ambiguous or legally sensitive
  • Unresolved — insufficient evidence to make a reliable claim

If information is unsafe or unresolved, AITHENA does not silently use it to calculate deadlines, financial totals or conflict conclusions.

We believe a legal AI system should know what it knows, know what it does not know, and know when a human needs to take over.

Challenges we faced

1. Making AI useful without allowing it to overclaim

Extracting text from a contract is relatively straightforward. Deciding whether that extracted information is reliable enough to drive business decisions is much harder.

We had to design explicit confidence, evidence and escalation behaviour rather than displaying every AI output as fact.

2. Handling contract portfolios instead of individual documents

A single-contract summariser was not enough for the problem we wanted to solve.

The system needed to reason across many contracts, calculate deadlines, aggregate obligations and compare clauses between different agreements.

This required us to separate AI interpretation from deterministic portfolio logic.

3. Working with different document formats

Real SME contract folders are messy. They can contain ordinary PDFs, DOCX documents and scanned contracts.

We therefore designed the ingestion and extraction pipeline to support mixed document types while preserving information about where each finding came from.

4. Turning legal information into actions

A renewal date alone is not necessarily the important date.

We had to distinguish between:

  • The contractual event date
  • The last contractual action-by date
  • Internal reminder dates

This changed AITHENA from a contract viewer into something closer to an operational early-warning system.

5. Knowing when not to answer

Some contract questions depend on interpretation, exceptions and legal judgement.

Rather than trying to automate those decisions away, we built Human Review directly into the product workflow.

What we learned

The biggest lesson was that building legal AI is not only about making the model more capable.

It is about designing the system around the model.

We learned that:

  • Legal AI needs evidence, not just fluent answers.
  • Uncertainty should affect downstream system behaviour.
  • Deterministic code is more appropriate than an LLM for calculations such as deadlines.
  • Portfolio-level intelligence can be more valuable than individual contract summaries.
  • Human escalation is a product feature, not a failure of automation.
  • AI becomes more useful when it reduces the administrative work surrounding professional judgement rather than attempting to replace it.

Most importantly, we learned that a trustworthy AI system should not simply try to answer every question.

Sometimes the most useful response is:

“This needs human review — and here is exactly why.”

What's next

With more time, we would expand AITHENA with deeper portfolio search, additional conflict classes, richer integrations with shared-drive systems, stronger reminder workflows and more extensive evaluation across real-world contract types.

Our goal is to make contract management practical for SMEs that cannot justify expensive enterprise contract-management software.

AITHENA turns forgotten contracts into actionable intelligence:

Know what you owe.
Know what is next.
Know when to escalate.

Built With

Share this project:

Updates