The agent runtime that learns

Agents that get smarter every day.

Glen runs your team of agents and turns every run into knowledge. A curator writes what they learn into a shared knowledge base as they work, so each run starts smarter than the last. Every night it dreams to clean up and consolidate what they learned.

Read the film

    The film is a simulated story. Its agents, pages and counts illustrate the loop. They are not measurements.

    The problem

    Your agents can't learn.

    Running your own agents is hard to set up and hard to scale. And once they run, they don't get any smarter.

    Glen runs your agents and makes them smarter every day.

    It is built from the ground up for agents that develop knowledge over time.

    1. Run a team of agents

      Define an agent once. Glen starts a sandboxed session for every task and runs many at once.

    2. Every run becomes a lesson

      When a session ends, Glen sends the curator a synopsis: the trigger, the tool calls, the agent's account and what people said. You add feedback and corrections in chat.

    3. The curator writes the knowledge base

      Agents never write the knowledge base. The curator does, and so can your people, page by page. As runs finish, it uses the experience of all your agents to write pages and links, and every line cites the session or person it came from.

    4. Every night it dreams

      The way sleep consolidates memory, the curator rechecks pages against the real sessions. It fixes mistakes, removes lines that don't hold up, merges duplicate pages and tidies the index.

    5. Your agents get smarter every day

      Every agent reads the knowledge base before it works, and the knowledge base changes as runs finish. Each run starts from what the ones before it learned, and understands its context better.

    Agents can use almost any tool.

    An agent works with MCP servers, CLI tools, and any API you can reach from a CLI. That covers almost anything your team does by hand.

    Secrets are scoped per agent. An agent's sandbox only gets the keys its definition names.

    Tools

    • Codegithubgitgh
    • Advisoriesosvkev-feednvd
    • Logssiemdatadog
    • Identityokta
    • Cloudawskubectl
    • Ticketsjira
    • Commsslack

    Examples. Bring the MCP servers and CLIs your agents need.

    One knowledge base per team, product or part of the org.

    Glen holds many knowledge bases. Each agent reads one. Agents that share a knowledge base learn from each other.

    factory

    A software factory of coding agents.

    • pr-reviewer
    • test-fixer
    • engineer
    • dep-bumper

    repos/services/ci/conventions/deploys/decisions/

    secops

    A security team's agents.

    • cve-patcher
    • alert-triage
    • threat-hunter
    • access-review

    alerts/hosts/runbooks/teams/accounts/

    Knowledge you can read, correct and revert.

    The knowledge base is plain markdown. Agents read it as files. People read it in the console, where every revision is a diff you can revert.

    ci/flaky-checkout.md

    # Flaky checkout tests
    
    checkout's integration tests need the payments
    sandbox. Run make sandbox first. (session s-101)
    
    Never retry a failing migration test. A retry
    hides a real schema bug.
    (Operator alice, in chat, session s-103)
    
    Known flakes live in ci/flaky-tests.md.
    Quarantine them, don't delete them. (session s-102)
    
    ## Before you merge
    
    Changes under payments/ need a review from the
    payments team. Owners are in services/. (session s-099)
    
    A fix that breaks CI goes back as a draft PR,
    with the failing job linked. (session s-104)

    Every line cites the session or person it came from. Code, not the model, removes a line whose sources don't hold up.

    Session s-103, chat

    1. alice Don't retry the migration test. It is hiding a real schema bug.
    2. engineer Understood. I fixed the migration instead, and the suite passes.
    3. The curator filed alice's note in ci/flaky-checkout.md.

    Correct an agent where you already talk to it. Your words reach the curator verbatim.

    Build with Glen.

    In your product

    Run your product's agents behind Glen's API. Each one retrieves context from its knowledge base, so your product's agents get better with every run.

    Inside your company

    Run your own agents on your team's work. The curator builds a company brain: a knowledge base of what is going on that every agent, and every person, can read.

    What teams run on it

    A managed runtime, sealed where it matters.

    Glen runs the sessions, holds the secrets and keeps the record. You define the agents.

    Get started.

    1. 1Sign up

      Create your org and invite your team.

    2. 2Define an agent

      In Terraform, in the console, or through the API: its instructions, model, tools and the knowledge base it reads. Every change is a new version, shown as a diff.

      agents.tf

      resource "glen_agent" "engineer" {
        name           = "engineer"
        instructions   = file("engineer.md")
        model          = var.model
        knowledge_base = glen_knowledge_base.factory.name
      
        trigger { slack   = "#eng-requests" }
        trigger { webhook = "github:issues" }
      
        tools {
          mcp = ["github", "jira"]
          env = ["GITHUB_TOKEN", "JIRA_TOKEN"]
        }
      }

      engineer v4

      Knowledge
      factory
      Triggers
      slack #eng-requestsgithub issues
      Tools
      github MCPjira MCP

      v4, edited in the console by alice

      + trigger { slack = "#eng-requests" }

      v3, terraform apply

      - mcp = ["github"]
      + mcp = ["github", "jira"]
    3. 3Send it work

      From Slack, your API, a schedule, a feed or a GitHub webhook. Each piece of work starts a session.

      APIScheduleFeedsGitHub webhooksSlack

      POST /v1/send/engineer

      In Slack, agents post in your channels, and a thread is the session's chat.

    4. 4Watch it learn

      Every finished session sends a synopsis to the curator. The knowledge base grows with each run, and every night a dream rechecks and cleans it.

    Run a team of agents that learn.

    Get started