Agents Universe

An Apache-2.0 agent platform that treats a project as the unit of shared memory. Knowledge lives as Markdown files in the project workspace — domain/, technical/, skills/ — and a database table indexes them by project and slug: primary files are read into context in full when a project is selected, while detail files appear only as metadata and a summary until an agent loads one. There is no embedding model and no vector search; structure is carried by explicit [[slug]] cross-references. Writing back is the other half: knowledge_rw puts new interfaces, metric definitions and test patterns into the matching file, re-indexes, bumps a version, archives the previous content and recomputes a five-part completeness score, with stale marking and an explicit retirement step so that forgetting is auditable. Ten role definitions ship with it — Product Owner, Tech Lead, Quality Assurance and others — and a single turn can be routed to another agent with an @ mention, or delegate a subtask inside the same turn. Memory is layered from per-turn context through session, personal, episodic, project and global knowledge, and any agent can be published as an API or an embeddable page.

Who built itThe GitHub account that owns the repository, named yanqiu(Ian) on its profile, opened in November 2017, with four public repositories, no bio and no followers. Seventeen of the repository’s 235 commits are authored under that name and two more carry the display name Agents Universe with a localhost address; the remaining 216 are authored as Agent Universe with a GitHub noreply address and were committed through GitHub’s web flow rather than a local git client, which matches the README’s claim that the repository is maintained by its own Product Owner and Tech Lead agents. One hundred and eight commits carry co-author trailers — 65 naming Claude, 42 Claude Code, one Claude Opus 4.8.

1. 01

   One person, and the agents the project is about

   The repository was created on 2026-09-10 and its newest commit is dated 2026-09-28, but its oldest commit is dated 2026-08-18 and the changelog’s first version entry is dated 2026-08-08 — roughly three weeks of work arrived inside a repository that did not exist yet. The 235 commits split 99 in August and 136 in September, and the authorship is the part worth reading: 216 are authored as Agent Universe with a GitHub noreply address and committed through GitHub’s web flow, 17 are authored by the account owner, and 2 carry a localhost address. One hundred and eight carry co-author trailers — 65 Claude, 42 Claude Code, one Claude Opus 4.8 — and the contributor list has two entries, web-flow at 216 and the owner’s account at 17. Around that sit 383 stars, 1 fork, 0 watchers and a single open pull request, on an Apache-2.0 repository whose topics include deepseek-harness and workbuddy-alternative. Six tags exist, v1.0.0 through v1.5.0, and there are no GitHub releases at all; the release ledger is a 59,990-byte CHANGELOG.md whose version headings run from 0.1.0 on 2026-08-08 to 1.5.0 on 2026-09-24, with an Unreleased section holding the newest fixes.

2. 02

   Two writers, one file, and where the collisions were fixed

   A knowledge entry is a Markdown file in the project workspace and the database row is an index of it, which puts every consistency problem at the same seam. When concurrent indexer runs inserted duplicate rows for one project and slug, reads through scalar_one_or_none began raising MultipleResultsFound; migration w5h8k6g9h457 deduplicated the table by keeping the newest row per pair, deleting each loser’s load events and versions first, and then made the index unique. The indexer now flushes each file inside a savepoint and, on a lost insert race, re-fetches the winner and falls through to the update branch instead of abandoning the batch — with a comment recording that the add() has to sit inside the savepoint, because an object added before it survives the rollback as pending and re-raises outside any savepoint, aborting the batch anyway. The heaviest fix is on the human path: the knowledge PUT left its transaction open, so the background reindex’s update on the same metadata row blocked on the row lock while the response was still waiting — a deadlock that hung the PostgreSQL job for 40 minutes. That endpoint now writes the file, snapshots the previous content into knowledge_versions with the user as the changer, commits, and only then reindexes in a new session and invalidates the process-level cache, because otherwise the next conversation keeps serving stale entries.

3. 03

   What counts as learning, and the path it takes back into the files

   Learning here is read and write rather than search. Documents handed over — a Confluence page, a Swagger export, a requirements document — go through a knowledge-ingestion workflow that decides which entry each one belongs to, extracts the useful parts and writes structured entries with cross-references, asking whether to update an existing entry or create a new one when something similar is already there. During work the same thing happens through knowledge_rw: a new interface goes into api-map.md, a metric definition into metric-catalog.md, a test lesson into test-patterns.md. Every write re-indexes, updates the completeness score, archives the old text in knowledge_versions and appends to history.md; a brand-new slug gets an advisory nudge to fill an existing file first, exempting the API and Kong detail trees and genuine hierarchy children. Forgetting has a process too: outdated entries are marked and retired after the user confirms, and a purge operation removes index rows whose files are gone. The other write path is automatic — an episodic summary of a conversation, built from the last 50 messages once at least three came from the user, on the user’s first configured model, and triggered only by a passive WebSocket disconnect while no turn is active, because snapshotting a partial conversation would then be locked in permanently by the one-episode-per-conversation early return.

4. 04

   What is shared, and where the boundary is drawn

   The sharing is deliberately uneven. Knowledge queries are always scoped to the current project or to the global framework rows, switching projects clears session state, and each project gets its own workspace under PROJECTS_ROOT outside the repository. A private project carries a member list — the creator pastes a single sign-on user identifier because there is no username directory, members may manage the list themselves, and the visibility toggle stays with the creator; a check-then-insert race on that list returns 409 rather than 500. Secrets are the sharpest line: model keys and Git tokens are encrypted with AES-256-GCM in two separate vaults, resolved server-side into a subprocess environment for the tools that need them, and never placed in the model’s context, while safe_env() strips credential variables from child processes. Execution runs in a two-layer sandbox — a shell command allowlist with per-segment and per-token path checks, and a CPython audit hook installed through sitecustomize that confines file writes — and the README states its limits instead of claiming isolation: os.stat and os.access raise no audit events, Node.js has no equivalent runtime hook, and in non-strict mode a non-Python child of a guarded Python process sits outside the file guard.

5. 05

   What the changelog admits

   A 32,376-character changelog that records its own repairs is the most useful document in this repository, and the failures it lists are specific. Nginx died silently three times in fifteen hours while the container stayed up and the public site served 502s, because the entrypoint had given PID 1 to uvicorn; the entrypoint is now a supervisor loop that restarts nginx and clears the orphaned workers still holding the ports. A banner told users their last run had been interrupted and invited them to keep typing while the run was in fact still going — a 16-second run was settled as interrupted while the same conversation kept producing output for an hour, because the API treated a mid-turn injection as terminal and finish_run could then only no-op. A knowledge completeness endpoint returned 500 on every PostgreSQL deployment while local development and the SQLite tests were green, because the rounding function has no double-precision overload there. Continuous integration never installed a browser, so seven real Chromium tests skipped silently in every job; installing it moved that job from 1,649 passed and 9 skipped to 1,656 and 2. Background tasks leaked out of finished tests and left SQLite write transactions open, so later tests failed at random with database is locked — and the newest commit in the repository is that fix, draining detached tasks before the per-test engine is disposed. The global indexer had also swept all 29 templates into every project’s knowledge panel as system rows nobody could delete, which took a skip rule plus a migration to undo.

6. 06

   The community round, and the contract that guards the commits

   Outside contributions are three pull requests from one account, Mark-super-code, created on 2026-08-21, with one public repository, no followers and no display name. Two were merged about a minute after being opened — 60 seconds and 53 seconds — and the third, opened on 2026-09-28, is the repository’s single open item; its one comment is the author’s own follow-up rather than a review. That request proposes raising the filesystem tool’s read cap from 2 MB to 5 MB and mirroring the same constant in the API router, on the grounds that the router documents its byte caps as mirroring the tool, so leaving it would let an agent read a file that the workspace viewer answers with 413. It also reports the suite honestly — 1,597 passed, 2 skipped, 47 failed — and shows the failures to be pre-existing by stashing the change and re-running. The build itself follows a written hygiene contract: commit identity on a GitHub noreply address, sample hosts confined to the reserved example.com family, enforced by scripts/check_commit_hygiene.py through two pre-commit hooks and a CI job, added precisely because the platform’s own agents commit through a server-side clone where local hooks cannot be installed.