factory
A software factory of coding agents.
- pr-reviewer
- test-fixer
- engineer
- dep-bumper
repos/services/ci/conventions/deploys/decisions/
The agent runtime that learns
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.
The film is a simulated story. Its agents, pages and counts illustrate the loop. They are not measurements.
The problem
Running your own agents is hard to set up and hard to scale. And once they run, they don't get any smarter.
You correct an agent today. Tomorrow it makes the same mistake.
Every run starts from zero.
What one agent learns, the others never hear.
It is built from the ground up for agents that develop knowledge over time.
Define an agent once. Glen starts a sandboxed session for every task and runs many at once.
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.
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.
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.
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.
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
githubgitghosvkev-feednvdsiemdatadogoktaawskubectljiraslackExamples. Bring the MCP servers and CLIs your agents need.
Glen holds many knowledge bases. Each agent reads one. Agents that share a knowledge base learn from each other.
A software factory of coding agents.
repos/services/ci/conventions/deploys/decisions/
A security team's agents.
alerts/hosts/runbooks/teams/accounts/
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
ci/flaky-checkout.md.Correct an agent where you already talk to it. Your words reach the curator verbatim.
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.
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.
Picks up issues, writes the change, runs the tests and opens the PR. Learns your repos' conventions, your CI's quirks and what reviewers push back on.
Watches CISA KEV, NVD and OSV, finds affected dependencies and opens fixes. Learns which bumps broke CI and which services never auto-merge.
Rechecks detection rules when the query language changes and ports upstream fixes. Learns reviewer verdicts and query gotchas.
On a schedule, scores files by bug risk and opens reports. Learns which reports were confirmed and which areas to ignore.
Triages findings with the context an expert uses: exposure, owners, compliance scope and risk accepted before.
Reads customer threads and tickets and tells the team when a requested fix ships. Learns which customers care about what.
Glen runs the sessions, holds the secrets and keeps the record. You define the agents.
Every session runs in its own microVM on Amazon Bedrock AgentCore. A new session starts in about 2.5 seconds.1
The curator runs sealed: it reaches only Glen, with file tools only.
Secrets are scoped per agent. Model calls go through Glen's proxy, which holds each agent to its budget.
Every action is journaled, for audit and replay.
Create your org and invite your team.
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
v4, edited in the console by alice
+ trigger { slack = "#eng-requests" }
v3, terraform apply
- mcp = ["github"]
+ mcp = ["github", "jira"]
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.
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.