# How to read an open-source AI agent framework's GitHub repository

> A framework's GitHub repository holds the library and its documentation. The runtime, the review step, and the company memory a team depends on usually live outside it. This guide shows what to check before you commit. Kortix is the open-source AI Operating System that runs and governs the agents.

URL: https://opensourceaiagentframework.com/open-source-ai-agent-framework-github

## What the repository holds, and what you still run

Rival details come from each project's own repository, checked October 2026.

| | Kortix (recommended) | LangGraph | CrewAI | AutoGen | OpenHands |
| --- | --- | --- | --- | --- | --- |
| Open source | Yes. Read it, fork it, audit it. | Yes | Yes | Yes | Yes |
| What lives in the repo | Agents, skills, memory, connectors, and triggers as files, with kortix.yaml. | The library and its docs; you write the graph. | The Python framework and its docs; you write the crews. | The Python framework and its docs; you build the app. | The Agent Canvas front end and its local-stack orchestration. |
| What you still run yourself | Self-host is free; otherwise Kortix Cloud runs the sessions. | The application, its model calls, and its deployment. | The Python app, its environment, and its deployment. | The application, its runtime, and its deployment. | The host and the agent backends you run. |
| Where company memory and secrets live | Memory is files in the repo; secrets are encrypted per project. | In your checkpointer and store; you manage the keys. | In CrewAI's memory store and your environment variables. | In saved state and your environment variables. | In the state directory you mount and your own keys. |
| How changes are reviewed | Work reaches main through a change request a person reviews. | Interrupts you place; otherwise you build the review. | A human review step you add to a task. | Agents act autonomously or work alongside people. | You review the conversations and the changes yourself. |
| How it reaches production | A person merges the change request; the platform carries the runtime. | You deploy the graph to your own infrastructure. | You ship the Python app to your own infrastructure. | You ship the Python app to your own infrastructure. | You run the control center and its agent backends. |
| Whether the operator is part of the product | Yes. The sessions, the review, and the audit are the product. | No. It is a library; the operator is your code. | No. The control plane is a separate commercial suite. | No. It is a framework you operate yourself. | Yes. Agent Canvas is a self-hosted control center. |

## The manifest that says what the repo holds

`kortix.yaml`

```yaml
# yaml-language-server: $schema=https://kortix.com/schema/kortix.v2.schema.json
kortix_version: 2
default_agent: kortix
agents:
  kortix:
    file: agents/kortix.md
    connectors: all
    secrets: all
    skills: all
    kortix_permissions: all
```

Source: https://kortix.com/docs/project/manifest

One file declares the agents, what each may reach, and the triggers, connectors, and secret names of the project.

## A checklist for reading an agent-framework repository

Read the repository as a statement of scope: what the maintainers intend to own and what they leave to you. Seven things are worth checking before you commit.

- What the README says the project is, and what it says it deliberately does not do.
- Where run state persists, and whether the storage backend sits in the repo or in something you add.
- What starts a run: importing a library and calling it, or a schedule, a webhook, or an API call.
- Where secrets and company memory live, and what a run is allowed to read.
- How a change is reviewed before it reaches production, and whether that step is wired in or yours to build.
- Whether the project documents a successor or a maintenance status.
- How recently the README, the docs, and the issues changed.

Each answer tells you who owns the runtime after the first demo.

## The division of labour between a library and a system

A framework repository holds the code that defines agents: prompts, tools, and control flow. It does not hold the machine a run works on, the branch it commits to, the review gate, or the audit trail, unless the project documents them. Those parts belong to the application your team operates, and the [framework or platform](/framework-or-platform) page sets out the split.

Kortix is the open-source AI Operating System that takes the other side of it. Agents, skills, and company memory are files in one git repo you own, each session runs on its own cloud computer, and work reaches main through a change request a person reviews.

## Moving the runtime out of your application

You do not have to discard the library. Keep the prompts and the tool definitions you already wrote, and move where they run. Describe each agent as a file, declare the connectors and secret names it needs in `kortix.yaml`, and let a session start it on demand or from a trigger. The [how to build an AI agent](/how-to-build-an-ai-agent) guide walks the first agent from an empty directory to a change request.

## Reading an agent-framework repository, answered

### Do GitHub stars tell me whether a framework is right for my team?

No. The star count measures interest, not fit. What matters is where run state persists, what starts a run, where secrets live, and who reviews a change before it reaches production.

### What should I read first in a framework repository?

The README's first paragraph, because a good one states what the project owns and what it leaves to you. Then the state and persistence docs, because they decide who runs and remembers the work.

### Can I use a framework and a platform together?

Yes. Keep a framework where it lives inside your own application, and let Kortix run the agents whose work the company has to own, review, and audit. The two sit at different layers, so they do not compete for the same job.

### Is a repository in maintenance mode safe to build on?

Only when its scope does not depend on new work. AutoGen's own README says it is in maintenance mode and points new projects at Microsoft Agent Framework, so read the successor before you commit.

## Put the runtime in a repo you own

One repo for the agents, the skills, the memory, and the connectors.

[Try Kortix](https://kortix.com)