Why we built Sinas instead of building Enterprise AI on LangChain

Topic

Agentic Architecture

Kind

Perspective

Author

Kjeld Oostra

Read time

4 min read

/

/

Why we built Sinas instead of building Enterprise AI on LangChain

/

/

Why we built Sinas instead of building Enterprise AI on LangChain

LangChain helped define the first generation of LLM applications.

It gave developers a practical way to connect language models with prompts, retrieval systems, tools and external data.

For prototypes, experiments and many production applications, frameworks such as LangChain remain useful.

But as we started building increasingly complex enterprise AI systems, we encountered a different problem.

We were no longer building applications that called an LLM.

We were building systems in which AI could act.

That required a different foundation.

It is why we started building SINAS.

From chains to systems

Early generative AI applications were relatively linear.

A user sends a request.

The application retrieves context.

The LLM generates a response.

The user receives it.

The architecture can be represented as a chain.

Agentic systems behave differently.

A request may trigger:

  • intent recognition
  • planning
  • retrieval
  • database queries
  • code execution
  • multiple models
  • several agents
  • external APIs
  • validation
  • human approval
  • retries
  • long-running workflows

Execution branches.

Agents fail.

Tools return unexpected results.

Permissions change what can happen.

Humans sometimes need to intervene.

At that point, orchestration becomes infrastructure.

The problem is execution

Connecting an LLM to a tool is easy.

Letting an AI system safely execute actions inside a company is harder.

Suppose an agent receives this request:

Analyse our sales performance, identify accounts at risk and prepare follow-up actions in the CRM.

The system may need to query a database, execute calculations, retrieve customer information, generate recommendations and create CRM records.

Each action introduces questions.

Which agent can access the database?

Which tables?

Can it write data?

Can generated code execute?

Where does that code execute?

What happens if it fails?

Which actions require approval?

What gets logged?

How do we reproduce what happened?

These are infrastructure questions.

Sandboxed execution

Agents increasingly need code.

An LLM might generate Python to analyse a dataset, transform a file or calculate an output.

Running generated code directly inside application infrastructure creates an obvious security problem.

Execution therefore needs isolation.

A sandbox should limit access to:

  • filesystem
  • network
  • credentials
  • compute
  • runtime
  • external services

The agent gets enough capability to complete the task without receiving unrestricted access to the surrounding environment.

This becomes increasingly important as AI moves from generating text to executing work.

Agents need permissions

Most enterprise software is built around users and roles.

Agentic software introduces another actor.

The agent itself.

An agent should have an identity and defined capabilities.

It may be allowed to:

  • read selected data
  • call specific APIs
  • execute approved tools
  • prepare transactions

It may not be allowed to:

  • access payroll
  • export an entire database
  • send external communications
  • approve payments

unless explicitly authorised.

Permissions should exist outside the prompt.

Writing "never access confidential information" into a system instruction is not an access-control system.

Model independence

We also wanted the intelligence layer to remain replaceable.

Different workloads require different models.

Some may use OpenAI.

Some may use Anthropic.

Some may use Mistral.

Others may use local or specialised models.

An orchestration system should be able to select between them without requiring the underlying application to be rebuilt.

Models become interchangeable capabilities.

Human intervention

Enterprise automation rarely fits into two categories of completely manual or completely autonomous.

There are many levels between them.

An agent may research autonomously.

It may draft a proposal.

A human approves it.

The agent then updates another system.

SINAS treats human approval as part of execution rather than an external process bolted onto the application.

This lets workflows define exactly where human judgement is required.

Observability matters

When an agent produces an incorrect answer, debugging the final text is insufficient.

Engineering teams need to know what happened before the answer appeared.

Which model was called?

What context was retrieved?

Which tools ran?

What did those tools return?

Which decisions followed?

Were retries triggered?

Did a human intervene?

This execution history becomes essential for debugging, optimisation and governance.

Why not simply use LangChain?

Sometimes we do.

This is not an argument that every organisation should replace LangChain.

LangChain, LangGraph, AutoGen and other frameworks solve useful problems and continue developing rapidly.

SINAS exists because our requirements moved towards infrastructure for controlled enterprise execution.

The design priorities became:

  • sandboxed execution
  • model independence
  • explicit permissions
  • agent orchestration
  • human approval
  • persistent workflows
  • observability
  • deployment control

That led us towards a different abstraction.

Open infrastructure matters

We also believe a critical enterprise AI layer should be inspectable.

Organisations increasingly depend on AI systems to access knowledge and execute business processes.

That infrastructure should not automatically become another black box.

Open-source infrastructure gives engineering teams the ability to inspect, modify and deploy the system according to their own requirements.

For European enterprises, this also supports a wider goal: reducing unnecessary dependency at the intelligence layer.

What we think comes next

The first generation of AI development was about connecting software to models.

The next generation is about connecting intelligence to organisations.

That requires much more than prompting.

It requires execution environments, permissions, orchestration, observability, model routing and human control.

That is the problem SINAS is being built to solve.

LangChain helped developers build applications around LLMs.

We are building SINAS for a world where agents become part of the enterprise itself.

Avatar-1
Avatar-2
Avatar-4
Avatar-4
Avatar-3

Fresh insights, straight to your inbox.

Engineering breakdowns, sovereign-AI perspectives and practical guides from the people building enterprise AI. One email when there is something worth your time.