AI does not need another chat window. It needs context.

AI does not need another place to talk.

It needs somewhere useful to land.

A meeting summary is useful.
A list of action items is useful.
A generated risk register is useful.
A draft decision log is useful.

But in real project work, none of that is enough on its own.

The question is not only whether AI can produce something useful. The question is what happens after it produces it.

Because generated output is not the same as project context.

More output is not the same as more understanding

Most modern AI tools are very good at producing text.

They can summarize a meeting.
They can extract action points.
They can identify risks.
They can draft follow-ups.
They can explain a document.
They can generate structured suggestions from messy notes.

That is genuinely powerful.

But the problem in complex work has rarely been a lack of text.

Most companies already have too much of it.

Emails. Meeting notes. Presentations. Jira tickets. PLM records. Chat threads. Spreadsheets. Reports. Decision decks. Status updates. Risk logs. Local documents. Shared folders. Private notes.

The real problem is that the important parts are scattered.

A risk is mentioned in one meeting, then disappears into a summary.
A decision is made, but the reason is buried in a slide deck.
A follow-up is assigned, but nobody connects it to the asset or project it affects.
A dependency is discussed, but never becomes visible in the actual project structure.
A warning appears early, but only becomes obvious months later.

AI can help produce better summaries of that mess.

But summaries alone do not fix the mess.

Sometimes they just create a cleaner-looking version of it.

Context is not just more text

There is another problem that is easy to underestimate.

AI does not use context the way people often imagine it does.

When we give an AI system a long prompt, a long document, or a long conversation history, we tend to assume that everything inside it is equally available and equally weighted.

That is not always how it behaves.

Long-context models have improved a lot, but research has shown that models can still be better at using information placed near the beginning or the end of a long context, while important details buried in the middle may be used less reliably.

In practical terms, this matters.

The instruction at the top may be remembered.
The latest message at the bottom may dominate.
The important warning from twenty prompts ago may fade.
The decision hidden in the middle of a long meeting transcript may not be used.
The risk that was mentioned once may disappear behind newer, louder information.

This is not because the AI is careless.

It is because context is not the same as memory.

A context window is a limited working area. As conversations get longer, more information competes for attention. Older messages may be compressed, pushed out, summarized, or simply become less useful to the model. Even when the text technically fits, the model may not use every part of it equally well.

That is why “just give the AI more context” is not a complete solution.

More context can help.
But unmanaged context can also create a false sense of understanding.

Output needs to become accountable

For AI-generated work to be useful in serious projects, it needs to become accountable.

That means someone should be able to answer:

Where did this come from?
Who reviewed it?
Was it accepted, rejected, or left unresolved?
Which project does it belong to?
Which allocation, asset, risk, question, decision, or event does it affect?
When did it become true?
What changed because of it?
Can someone understand this six months later?

Without that, AI output remains fragile.

It may be helpful in the moment, but it does not become part of the project’s memory.

And that is where the risk starts.

Because polished output can look like evidence.
A confident summary can look like agreement.
A generated action list can look like ownership.
A decision draft can look like a decision.

But unless it is reviewed, connected, and traceable, it is not accountability.

It is only text.

Context should be reviewable

This is one of the reasons I think AI-generated project work needs a different kind of infrastructure.

If an AI suggests a risk, a decision, a follow-up, or an update to a project timeline, people should not only see the suggestion.

They should also be able to inspect the context behind it.

What source was used?
Which meeting note did it come from?
Which document was referenced?
Which previous decision was included?
Which relevant information was not used?
Was the suggestion based on the latest state of the project, or on stale context?
Was an important middle section ignored?

This is the idea behind what I think of as Nolta’s Open Context API.

Not an API that simply lets external tools throw text into a system.

An API that lets AI tools and external systems submit structured context proposals with provenance.

A proposed risk should carry its source.
A proposed decision should carry its evidence.
A proposed follow-up should show where it came from.
A proposed project update should show what context was used to create it.

And just as importantly, the review layer should make it possible to see what was not used, what was uncertain, and what still needs human judgement.

Because the real question is not only:

“What did the AI say?”

The better question is:

“What context did the AI rely on, and is that context enough?”

Nolta’s view: AI should propose, humans should decide

Nolta is being built around a simple idea:

Important project context should not disappear.

That includes context created by people.
It also includes context suggested by AI.

But there is a difference between suggestion and truth.

An AI agent might read meeting notes and suggest:

This looks like a new risk.
This sounds like a follow-up.
This may be a decision.
This should probably be linked to that asset.
This issue seems related to another allocation.
This comment may change the project timeline.

That is useful.

But it should not automatically become canonical project history just because it was generated fluently.

In Nolta, the better model is proposal first.

AI can suggest context.
A human can review it.
The system can preserve where it came from.
Then accepted items can become part of the project thread.

That is the difference between automation and accountability.

AI-agnostic by design

I do not believe every company will use the same AI model.

Some will use OpenAI.
Some will use Microsoft.
Some will use Google.
Some will use local models.
Some will use industry-specific tools.
Some will use several at once.

That is fine.

Nolta does not need to be the AI.

Nolta needs to be the place where useful AI output becomes structured, reviewable, time-aware project context.

That distinction matters.

If every tool builds its own little AI assistant, companies may end up with even more fragmented context than before. Every assistant knows a little. Every system has its own memory. Every workflow produces another partial truth.

The better long-term model is not one AI to rule them all.

It is a context layer that can receive structured proposals from different tools, preserve provenance, and help people decide what becomes part of the real project record.

A concrete example: meeting notes

Take a normal project meeting.

Today, the output might be a document, an email, or a chat summary.

It may include:

Three action items.
Two risks.
One unresolved question.
A decision that changes direction.
A dependency on another team.
A concern about a specific asset or delivery.
A topic that should be raised in the next leadership meeting.

In many companies, that information is useful for a few days and then starts to decay.

People remember different parts.
Some items make it into Jira.
Some stay in notes.
Some are copied into a PowerPoint.
Some are forgotten.

With an AI-assisted context layer, that same meeting could create proposed Nolta items:

A risk attached to the affected project or allocation.
A follow-up assigned to the right person.
A decision linked to the timeline.
A question connected to the relevant asset.
An event recorded at the correct date.
A relationship between two affected areas.
A leadership-review marker for the next status meeting.

But the important word is proposed.

Someone still reviews it.

Someone decides what is true, what is useful, what is noise, and what belongs in the project record.

That is where AI becomes operationally useful without pretending to be responsible.

The missing layer

The future of AI in project work is not only about generating more.

It is about helping teams understand what matters.

What changed?
Why did it change?
Who decided?
What is still unresolved?
What is connected?
What needs attention now?
What will people need to understand later?

That is the layer Nolta is being built for.

Not another chat window.
Not another dashboard full of disconnected summaries.
Not another place where important context goes to die.

A place where context can land.

A place where suggestions can be reviewed.

A place where time, decisions, risks, questions, assets, and people can be connected.

Because AI can help create the signal.

But the system still needs to remember where the signal came from, what it touched, what it missed, and who decided that it became part of the project record.

---

Notes

The long-context point is based on a careful wording of current AI behavior: long-context models may use information near the beginning and end of supplied context more reliably than information buried in the middle. A useful reference is the “Lost in the Middle” paper by Liu et al.

Source: https://arxiv.org/abs/2307.03172