Ana SayfaBlogProjeler
GitHubLinkedInTelegram
14 min read👁️ 2
Featured

Using Turkey's EVREN AI Infrastructure with a Coding Agent: EVREN LLM + OpenCode

Artificial Intelligence
Software Development
Open Source
Coding Agent
Turkish Technology

Using Turkey's EVREN AI Infrastructure with a Coding Agent: EVREN LLM + OpenCode

AI-assisted software development is no longer limited to asking a chatbot for a code snippet.

New-generation coding agent tools can read a project, understand relationships between files, run terminal commands, inspect tests, create new files, and carry out a development task step by step.

One of the most critical components behind all these systems is still the same:

LLM infrastructure.

One notable project in Turkey is the EVREN Platform.

Developed under the Presidency of Defence Industries, EVREN is not just a chat application. It aims to bring the entire AI development lifecycle together, from data preparation and model training to inference and model sharing, as a domestic AI and MLOps platform.

What makes EVREN even more interesting for developers is its LLM Inference Service.

In this article, we will first look at what EVREN is and then see how to use models on EVREN with the open-source coding agent OpenCode.

What Is EVREN?

An important distinction is necessary here.

It would not be entirely accurate to describe EVREN directly as:

A new large language model developed by Turkey

EVREN is a broader project.

EVREN is an AI and MLOps platform developed in Turkey.

The platform aims to bring together different stages of the AI lifecycle in one environment, including:

  • dataset preparation,
  • data labeling,
  • model development,
  • model training,
  • model testing,
  • model publishing,
  • inference services,
  • model sharing.

University announcements also describe EVREN as infrastructure for managing data preparation, data labeling, model development, training, testing, and publishing from end to end.

One notable feature of the platform is its contribution-based credit system.

Users can earn credits by contributing to the platform through activities such as uploading datasets or labeling data, and then use those credits to access GPU resources.

This approach offers an alternative way to access expensive GPU infrastructure, especially for:

  • students,
  • academics,
  • researchers,
  • AI developers,
  • startup teams.

EVREN LLM Inference Service

This is the part that matters most to us on the coding-agent side.

The EVREN Platform offers an LLM inference service that runs open-weight large language models on GPU infrastructure in Turkey.

One of its most important features is an OpenAI-compatible API.

This is a significant detail.

An OpenAI-compatible service does not have to be used only through EVREN's own web interface.

Many systems that support OpenAI-compatible providers can connect to EVREN, including:

  • coding agents,
  • IDE tools,
  • Python applications,
  • Node.js applications,
  • RAG systems,
  • agent frameworks,
  • backend services,
  • enterprise AI applications.

These systems can be integrated with the EVREN API.

Models Available on EVREN

The EVREN LLM service includes models for different use cases.

For coding agents, models with reasoning, code, and agent capabilities are particularly relevant.

For example:

glm-5.3
deepseek-v4-flash
qwen3.8-flash-next
gemma-4-31b

For scenarios that require visual capabilities, models such as:

qwen3-vl-30b

can be used.

EVREN is not limited to LLMs. The platform can also provide services for different tasks, including:

  • embeddings,
  • reranking,
  • OCR,
  • ASR,
  • security,
  • image processing.

This makes EVREN more than a chatbot service. It becomes an AI infrastructure on which applications and agents can be built.

Local Infrastructure, Global Models

Another important distinction is needed here.

Models such as:

  • GLM,
  • DeepSeek,
  • Qwen,
  • Gemma

used on EVREN are not foundation models developed in Turkey.

The domestic aspect of EVREN is mainly visible in these layers:

GPU infrastructure
    ↓
MLOps platform
    ↓
Model serving layer
    ↓
OpenAI-compatible API
    ↓
Developer tools

In other words, open-weight global models run on infrastructure in Turkey and are offered to developers through a common API.

This distinction matters.

A strong AI ecosystem is not made up of model development alone. It also needs layers such as:

  • compute,
  • data,
  • tooling,
  • APIs,
  • deployment,
  • model serving,
  • developer ecosystems.

EVREN is making an important contribution at this infrastructure layer.

What Is a Coding Agent?

Let us move to software development.

With tools such as:

  • Claude Code,
  • Codex CLI,
  • Gemini CLI,
  • OpenCode,

the idea of an AI coding assistant is increasingly turning into the coding agent approach.

The difference between a traditional chatbot and a coding agent is significant.

If you ask a regular chatbot:

Write an example of JWT authentication in Python.

it will generate code for you.

With a coding agent, you can give it a task such as:

Inspect the authentication structure in this project.

Add refresh-token support.

Do not break the existing architecture.

Update and run the tests.

During this task, a coding agent can:

Read project files
        ↓
Analyze the codebase
        ↓
Create a plan
        ↓
Modify files
        ↓
Run terminal commands
        ↓
Run tests
        ↓
Analyze errors
        ↓
Refactor the code when necessary

For this reason, coding agents offer a much more advanced workflow than traditional code-completion tools.

What Is OpenCode?

OpenCode is an open-source AI coding agent.

It runs in the terminal and can connect to different LLM providers.

One of OpenCode's important advantages is that it is not tied to a single AI provider.

In addition to different built-in providers, OpenCode supports custom OpenAI-compatible providers.

For example, a custom provider can be configured like this:

{
  "provider": {
    "my-provider": {
      "npm": "@ai-sdk/openai-compatible",
      "options": {
        "baseURL": "https://example.com/v1"
      }
    }
  }
}

The EVREN integration uses exactly this mechanism.

Because EVREN provides an OpenAI-compatible API, we can add a custom provider named:

evren

to OpenCode.

The evren-llm-opencode Project

I developed the following open-source project to make this integration easier:

evren-llm-opencode

GitHub:

github.com/bykemalh/evren-llm-opencode

The goal of the project is simple:

Add the EVREN LLM provider to OpenCode as easily as possible.

Normally, users need to:

  • find their OpenCode configuration file,
  • define the EVREN endpoint,
  • add models one by one,
  • configure the API key,
  • add the provider without breaking the existing configuration.

evren-llm-opencode automates these steps.

Supported Platforms

The project currently supports:

  • Linux,
  • WSL,
  • macOS,
  • Windows PowerShell,
  • Windows CMD.

Instead of replacing your existing OpenCode configuration, it adds only the required evren provider block.

Existing providers are preserved.

API Key Security

Writing an API key directly into a configuration file is not a good practice.

For this reason, the project does not write the API key in plain text into opencode.jsonc.

Instead, it uses:

{
  "apiKey": "{env:EVREN_LLM_API_KEY}"
}

The real API key is stored in an environment variable:

EVREN_LLM_API_KEY

This prevents your API key from appearing in the repository if you accidentally push the configuration file to GitHub.

You should still make sure that .env, shell configuration files, and secret files are not added to Git.

Getting an EVREN API Key

First, sign in to the EVREN Platform.

The platform is available at:

https://evren.ssyz.org.tr

Keys created for LLM API access start with this prefix:

evren_llm_...

Never add your API key to:

  • a GitHub repository,
  • source code,
  • a Docker image,
  • public configuration files.

Installing OpenCode

If you use Linux or WSL, you can install OpenCode from the terminal:

curl -fsSL https://opencode.ai/v2/install | bash

After installation, open a new terminal.

Alternatively, run:

source ~/.bashrc

Check the installation with:

opencode --version

Connecting EVREN to OpenCode

You can configure the EVREN provider with a single command.

Linux, WSL, or macOS:

curl -fsSL https://raw.githubusercontent.com/bykemalh/evren-llm-opencode/main/evren-opencode.sh | bash

Reviewing internet-downloaded scripts before executing them directly with bash is a good security habit.

You can also clone the repository and run the script locally:

git clone https://github.com/bykemalh/evren-llm-opencode.git

cd evren-llm-opencode

./evren-opencode.sh

What Happens During Installation?

When the script runs, it first asks for your EVREN API key:

=== EVREN LLM + OpenCode Setup ===
Enter your EVREN LLM API key:

The API key is not displayed openly in the terminal.

The script then essentially performs these steps:

  1. Validates the EVREN API key format.
  2. Queries the status of the EVREN terms of use.
  3. Verifies whether the terms have been accepted.
  4. Backs up the existing OpenCode configuration.
  5. Adds the EVREN provider block to the configuration.
  6. Stores the API key as an environment variable.
  7. Verifies the provider with opencode models.

After a successful installation, you may see output similar to this:

evren/auto
evren/deepseek-v4-flash
evren/gemma-4-31b
evren/glm-5.3
evren/qwen3-vl-30b
evren/qwen3.8-flash-next

If you see:

[OK] OpenCode can read the EVREN provider.

the integration is working.

Your First EVREN Test

For example, we can send a simple request with GLM 5.3:

opencode run --model evren/glm-5.3 "Reply with EVREN OK only."

If the model responds, OpenCode can now call a model through the EVREN API.

Using It as a Coding Agent

Now let us look at the practical workflow.

Go to your project directory:

cd ~/projects/my-app

Start OpenCode:

opencode

You can then select one of the models in the EVREN provider, for example:

evren/glm-5.3

Instead of asking the model isolated coding questions, you can now let it work across an entire repository.

Ask the Agent to Analyze the Project First

When using a coding agent, it is generally healthier to ask for analysis before allowing code changes.

For example:

Analyze this repository.

Explain the backend architecture.

Find out how the authentication system works.

Analyze the database layer.

Do not modify any files yet.

First prepare a plan for possible improvements.

This gives you the following workflow:

ANALYSIS
   ↓
PLAN
   ↓
CHANGES

Developing a New Feature

Suppose we have a Node.js backend project.

We could give the agent this task:

Inspect this project.

Add refresh-token support to the existing user authentication system.

Rules:

- Preserve the existing architecture.
- Do not add unnecessary dependencies.
- If a new dependency is required, explain why.
- Create a database migration if necessary.
- Add unit tests.
- Run the tests after the changes.

The coding agent does not merely return a code block. It can:

  • find the relevant files,
  • analyze the codebase,
  • understand the existing architecture,
  • modify files,
  • run terminal commands,
  • inspect test results,
  • revise the code based on errors.

Analyzing a Large Repository

One of the most useful applications of coding agents is quickly understanding a codebase you have not seen before.

For example:

Analyze this repository.

Explain the following:

1. The main application architecture
2. The request entry point
3. The authentication structure
4. The database layer
5. The background job system
6. The test infrastructure
7. The most critical technical debt

Do not modify any files yet.

This is particularly useful for:

  • projects you have recently joined,
  • legacy systems,
  • open-source repository reviews,
  • technical-debt analysis.

Fixing Bugs

You can also ask coding agents to investigate errors directly.

For example:

We occasionally receive a 500 error during login.

First find the relevant code.

Inspect the logging and exception-handling flow.

Identify the likely cause.

Do not change the code before confirming the cause.

Once you find it, fix it with the minimum change.

Also add a relevant regression test.

Here, the model's reasoning ability becomes important.

In particular, models such as:

evren/glm-5.3

or:

evren/deepseek-v4-flash

can be tested in different coding scenarios.

Code Reviews

You do not always have to ask a coding agent to write code.

It can also review your existing changes.

For example:

Review the changes in the latest commit.

Pay particular attention to:

- security vulnerabilities,
- race conditions,
- unnecessary database queries,
- error handling,
- backward compatibility,
- missing tests.

Do not modify files.

Only explain the findings and their causes.

This can be useful as a second review before opening a pull request.

Refactoring

Another use case is refactoring.

For example:

Analyze this service.

Identify duplicated code.

Prepare a plan to simplify the code without changing its behavior.

Do not change the public API.

Show the plan first.

Then perform the refactoring and run the tests.

The agent can help improve code quality while preserving existing behavior.

Writing Tests

Another area where coding agents are useful is creating tests.

For example:

Inspect the existing behavior of this module.

Find missing edge cases.

Create unit tests using the existing test framework.

Change production code only when truly necessary.

Run the complete test suite.

This produces tests that match the repository's existing approach rather than isolated generated examples.

Which EVREN Model Should You Use?

It would be incorrect to consider one model the best for every task.

Trying different models for different tasks is more reasonable.

A good starting point is:

evren/glm-5.3

You can also compare:

evren/deepseek-v4-flash

and:

evren/qwen3.8-flash-next

on the same task.

For general use, there is also:

evren/auto

For scenarios that require visual input, use:

evren/qwen3-vl-30b

The model list may change over time, so checking the current model list on the EVREN Platform is useful.

Why Is EVREN + OpenCode Interesting?

The key point is not simply adding a few new models to OpenCode.

The bigger picture looks like this:

GPU infrastructure in Turkey
          ↓
        EVREN
          ↓
 OpenAI-compatible API
          ↓
      OpenCode
          ↓
     Coding Agent
          ↓
Real software projects

An AI infrastructure operating in Turkey can become the model layer for modern agentic software-development tools.

That is significant.

The coding-agent ecosystem is evolving quickly, and many of these tools are becoming provider-independent.

The OpenAI-compatible API standard serves as an important bridge here.

When a provider supports this standard, integration with different developer tools becomes much easier.

The evren-llm-opencode project connects these two worlds:

EVREN
   +
OpenCode
   =
EVREN-powered Coding Agent

Uninstalling the Integration

If you want to remove the EVREN integration, use the repository's uninstall feature.

Linux/macOS:

./evren-opencode.sh --uninstall

The script:

  • removes the evren provider from the OpenCode configuration,
  • clears the EVREN_LLM_API_KEY environment-variable definition,
  • leaves other providers and OpenCode settings untouched.

Conclusion

Coding agents are rapidly changing how we develop software.

However, an agent's success does not depend only on the terminal interface or IDE you use.

The underlying model, inference infrastructure, API performance, context capabilities, and reasoning ability also matter greatly.

EVREN's OpenAI-compatible LLM API is therefore a notable development for developers in Turkey.

When combined with a provider-independent, open-source coding agent such as OpenCode, EVREN can be used on real software projects.

The open-source project I developed for the installation is:

evren-llm-opencode

https://github.com/bykemalh/evren-llm-opencode

Linux / WSL / macOS installation:

curl -fsSL https://raw.githubusercontent.com/bykemalh/evren-llm-opencode/main/evren-opencode.sh | bash

Installation test:

opencode run --model evren/glm-5.3 "Reply with EVREN OK only."

Then enter your project:

cd my-project

opencode

and start using the coding agent.

EVREN is not only a service for chatting. It can also serve as the model infrastructure for coding agents that work on real software projects.

Sources

Project

GitHub: bykemalh/evren-llm-opencode

One-command installation:

curl -fsSL https://raw.githubusercontent.com/bykemalh/evren-llm-opencode/main/evren-opencode.sh | bash