Beyond Entity — Architecture Memory for AI Coding Agents

English · 한국어 · 日本語

Beyond Entity gives AI agents and engineers a persistent, shared architecture memory: system intent, design decisions, models, data contracts, processor transformations, and implementation context that can be carried from one work session to the next.

The beyond-entity-mcp plugin connects this architecture memory to an AI coding workflow through the local Beyond Entity MCP server. Its skill guides an agent to recover context, check the design before changing code, keep architecture aligned with verified implementation changes, and leave a checkpoint for the next agent or human.

Use Beyond Entity for software architecture modeling, architecture diagrams, data lineage, and design-to-code workflows with Claude Code or Codex through MCP (Model Context Protocol).

Download Beyond Entity · Installation guide · User guide (한국어 · 日本語) · Sample projects · Website · GitHub

Recent upgrades

• Security vulnerability checks: review security pre-check findings with severity, status, source locations, evidence paths, and related architecture objects.
• Spring Code Parser: the spring_code_parser/ folder now includes a ready-to-run parser package that extracts architecture and data lineage from existing Java/Spring Boot and eGovFrame code, including Controller, Service, and Data Access layers. See the parser guide and framework samples.
• Changes in each Checkpoint: open a checkpoint's changed objects to inspect additions, updates, and deletions within its interval. Added and updated objects show their final values; deleted objects show their values immediately before deletion.
• Requirements interviews and project budget analysis through MCP: connect Claude Code or Codex to Beyond Entity through MCP to collect and refine project requirements through an interview, then analyze the project budget based on the collected requirements and agreed assumptions.

Explore architecture extracted from Spring code: Petclinic controllers and repositories connected to database entities and attributes. Click the image for the Spring Boot and eGovFrame sample guide.

Start from a design or from existing code

You can build architecture memory from either direction:

• Start with design. Ask your AI agent to turn your requirements into a design in Beyond Entity through MCP, including system boundaries, entities, data contracts, processors, and transformations. You can also design web and app architectures, ERDs, APIs, ETL/ELT pipelines, and schedulers directly in the Beyond Entity app, or combine hands-on modeling with AI assistance. Review and refine the design together, then ask the agent to implement it.
• Start with existing code. Ask your agent to inspect a codebase, extract its architecture and data flows, and record the corresponding models and design documentation in Beyond Entity through MCP. Review the extracted design and distinguish code-backed facts from inferred intent or unresolved questions.

Both approaches lead to the same workflow: use the architecture as a shared reference while coding, and keep it aligned with verified implementation changes. You can start with one feature or service and expand the architecture memory as needed.

Ask AI to reference the design while coding

Ask your coding agent to consult Beyond Entity before implementing a feature, fixing a bug, or refactoring. The agent can read the relevant processor transformations, input/output contracts, and dependencies through MCP, then use that context to guide its changes.

When the requested behavior changes the architecture, ask the agent to update the corresponding BE design and record why it changed. This makes the design useful throughout development and preserves context for the next agent or engineer. Design reference is an agent workflow, not an automatic guarantee that generated code conforms; verify the implementation against the design.

How it works

1. Recover context. Read the latest checkpoint and relevant project documents; inspect changes made by other agents or humans.
2. Check the design. Locate the affected processor and read its current transformations, input/output entities, and attributes before modifying code.
3. Implement and synchronize. Make the requested change and update the affected architecture when modeled behavior changes. Investigate discrepancies rather than assuming every code difference is intentional.
4. Verify and hand off. Check that implementation and design agree, then record completed changes, rationale, verification, and remaining work in a checkpoint.

Project reads and writes go through MCP. The skill directs agents to re-read current state rather than rely on old chat context or edit BE project database files directly. A review-only request remains read-only.

Explore architecture at different levels of detail

The default model view shows all attributes expanded for detailed inspection. Satellite View and user-created canvases initially show compact boxes with entity or processor names, keeping larger diagrams readable. Use the expand control on a box to reveal its attributes when you need more detail.

Collapsing a box changes its presentation; it does not mean the entity or processor has no attributes. You can review the overall structure first, then expand the parts relevant to the current task.

Keep the overall canvas compact and expand selected entities or processors to inspect their attributes and mappings. Click the image to open the viewer.

Comparing Beyond Entity and Archify

Exploring AI architecture diagram tools such as Archify? Archify generates interactive HTML/SVG diagrams from code or system descriptions, with snapshot comparisons and authored route tracing.

Beyond Entity focuses on persistent architecture memory for AI coding agents: editable entities, attributes, processor transformations, ERDs, and data lineage, with checkpoints that preserve design and implementation context across sessions. Humans review the model in the app; agents read and update it through MCP.

When comparing tools, consider whether your next task is to present an interactive system diagram or maintain a shared design that agents consult and update while coding. Explore the Table Q design and implementation to see the BE workflow. These are independent projects; this repository does not provide an Archify integration or automatic import.

Get started

• Install Beyond Entity for macOS or Windows from the official download page.
• Follow INSTALL.md to connect the bundled beyond-entity-mcp server and the architecture-memory skill to Claude Code (via the plugin marketplace) or Codex.
• Open a project in Beyond Entity, or explore a sample below.

The desktop app supplies the MCP executable. This repository supplies its plugin configuration and architecture-memory skill; downloading this repository alone does not install the desktop app.

Example requests

Design to code

Design this feature in Beyond Entity first, including its entities, processors, and transformations. Then implement it using that design as the reference and verify that the behavior matches.

Code to design

Inspect this existing codebase and extract its architecture into Beyond Entity through MCP. Map the data structures, processing responsibilities, and data flows, and identify any design intent that needs confirmation.

Code with architecture context

Use the current Beyond Entity design as your reference while implementing this feature. Read the relevant processor transformations before editing, preserve existing contracts, and synchronize any intentional design changes afterward.

Continue shared work

Use Beyond Entity as architecture memory for this project. Read the latest checkpoint and summarize relevant changes since the previous handoff.

Before changing this endpoint, find its processor and inspect the transformation design. Compare it with the current implementation.

Update the implementation and corresponding BE architecture for this change, verify their agreement, and leave a checkpoint for the next developer.

Samples

Compare Databricks and Snowflake: architecture, implementation structure, corrections, and business questions.

The guides include .bemdl download links. Table Q includes the Codex-generated implementation and its companion database schema. See the Table Q setup notes before running it.

More samples →

Spring Boot and eGovFrame framework layers

Beyond Entity now represents Controller Layer, Service Layer, and Data Access Layer responsibilities alongside application modules, data stores, and attribute-level lineage. Explore spring-petclinic, egovframe-msa-edu, egovframe-ai-rag, and payment-platform in the framework sample guide, with screenshots of layered architecture, checkpoints, and security pre-check findings. The AI/RAG and payment samples include AI review and false-positive corrections recorded in checkpoints.

View the samples online or download their models.

Repository layout

.
├── README.md, README_ko.md, README_ja.md # Overview in three languages
├── INSTALL.md                          # Desktop, MCP, skill, and parser setup
├── LICENSE
├── docs/                               # User guides in three languages
├── assets/screenshots/                 # README screenshots
├── .claude-plugin/marketplace.json     # Claude Code plugin marketplace
├── plugins/beyond-entity-mcp/
│   ├── .claude-plugin/plugin.json      # Claude Code plugin manifest
│   ├── .codex-plugin/plugin.json       # Codex plugin manifest
│   ├── .mcp.json                       # MCP server connection
│   └── skills/architecture-memory/
│       ├── SKILL.md
│       └── references/modeling-principles.md
├── spring_code_parser/                 # Ready-to-run Java/Spring analyzer
│   ├── README.md, README_ko.md, README_ja.md
│   ├── INSTALL.md, SECURITY.md
│   ├── bin/be-parser                   # macOS/Linux launcher
│   ├── bin/be-parser.cmd               # Windows launcher
│   ├── lib/be-extractor.jar            # Parser executable (Java 21+)
│   ├── install.sh
│   └── be-extractor.example.properties
└── samples/
    ├── README.md
    ├── spring-framework/               # Petclinic, eGovFrame MSA, AI/RAG, payments
    │   ├── README.md                   # Guide and online model catalog link
    │   └── images/                     # Architecture, checkpoints, security findings
    ├── table-q/                        # Guide, source, and database schema
    ├── ecommerce/README.md
    ├── databricks/                     # Python, jobs, tests, architecture notes
    ├── snowflake/                      # SQL, Python pipelines, DAGs, tests
    └── COMPARISON.md

This repository is a self-hosted Claude Code plugin marketplace (.claude-plugin/marketplace.json) that also ships the equivalent Codex plugin. Publish it by pushing the repository to a public Git host — no central review is required, and users can add it immediately (see INSTALL.md). Listing in Anthropic's community plugin directory is a separate, optional submission.

License

The MIT License applies to the plugin configuration, skills, documentation, and sample code in this repository. The Beyond Entity desktop application and separately distributed MCP executable are governed by their own license terms. Third-party components retain their respective licenses.