Skip to main content
EllygentDefine intent. Build with context.
Login
Define your first feature

Connect system intent to requirements—and give implementation the context it needs.

Ellygent helps systems and software teams clarify expected behavior, preserve where requirements come from, and prepare context for developers and AI coding tools.

Start with one feature. Make the missing decisions explicit, connect a requirement to its reason, and share a definition your team can review.

Try an exampleDefine your first feature

Create an account, then set up your project and choose the definition steps it needs.

Remote unlock / illustrative sample

Initial request

Let users unlock the door from the app.

Unresolved · DEC-04

How long should we wait for physical confirmation?

SW-01 · proposed requirement

The app shall display Unlocked only after receiving the controller’s physical unlocked-state confirmation correlated to the current request.

Source · SCN-01 → DEC-02 → SW-01

The remote-unlock scenario needs physical confirmation. Accepting a request does not confirm that the door unlocked.

Handoff preview

Definition summary · proposed requirements · source notes · open decisions

Explore the worked example →

Missing intent becomes implementation decisions.

Teams often start with incomplete input. Ellygent helps make the missing questions visible before developers and AI have to fill the gaps.

A feature request arrives. The expected behavior does not.

Delivery pressure and fragmented stakeholder input leave scope, users and failure paths unresolved.

Software requirements exist. Their system origin is unclear.

The team can verify individual requirements while still missing the intended system behavior.

The same questions keep returning during implementation.

Developers reconstruct intent from tickets and conversations. Different interpretations become different behavior.

AI generates code quickly, from incomplete intent.

A coding assistant fills missing decisions with assumptions too. The mismatch may surface only at integration.

Give implementation the reasoning behind the requirements.

Connect system intent, scenarios and constraints to system and software requirements. Traceability preserves why the expected behavior exists, so the next developer does not have to reconstruct it.

Review AI proposals before accepting them into your project. Then select the context you want to share: download a definition summary, export specifications, or pull a context package into your development workspace.

See context export and CLI access

Remote unlock · implementation handoff

Start with a definition summary, then share the relevant specifications and source relationships. Unresolved and deferred decisions remain visible in this sample. AI proposals require engineering review.

Generated with Ellygent’s definition-summary exporter. Proposed requirements and source IDs here are authored review notes in Additional Information; structured specification exports are separate.

# System Definition Summary

**Project:** Remote unlock — illustrative public sample

---

## Problem Statement

### Problem
Illustrative public sample — Let users unlock the door from the app.

### Current State
The feature request does not define authorization, failure behavior or confirmation.

### Impact
Developers would otherwise have to choose how to interpret request success.

### Context & Environment
A resident uses a mobile app, an access service and a connected door controller. Connectivity can fail between a request and physical actuation.

### Constraints
Accepting a request does not confirm physical unlocking. All requirements below are proposals for engineering review.

### Stakeholders
- Resident
- Access administrator
- Systems and software engineers

### Additional Considerations
- Sample revision: demo-v1; this is not a saved project baseline.
- Public example choices stay in this page and are not saved to a project.

## Mission Objectives

### 1. Give authorized residents remote access with an accurate reported outcome.
**Metric:** Compare the app’s reported outcome with the controller’s physical state in scenario tests.
**Target:** Never report Unlocked from request acceptance alone.

## Concept of Operations

### Actors
- **Resident** (human) — Requests access from the app.
- **Door controller** (system) — Actuates the lock and reports its physical state.

### Operational Domains
- Connected building access

### Environment Constraints
- Connectivity can fail during an unlock request.

### Scope: Included
- Remote request, authorization, lock actuation and outcome reporting

### Scope: Excluded
- Mechanical key access
- Emergency egress design

### Additional Information
Sample proposed requirements and source notes (authored review notes; not a specification export):

SYS-01 [System; proposed — engineering review required]: For a resident whose grant remains valid through dispatch, when the controller is online and accepts the command, the system shall actuate the lock and report its physical unlocked state for that request.
Sources: SCN-01; DEC-01, DEC-02.

SW-01 [Software; proposed — engineering review required]: The app shall display Unlocked only after receiving the controller’s physical unlocked-state confirmation correlated to the current request.
Sources: SCN-01; DEC-02; contributes to SYS-01.

SW-02 [Software; conditional draft — decisions pending]: When the controller is known to be offline, the access service shall reject the remote request without queuing a command, and the app shall display Device unavailable.
Sources: SCN-01; DEC-03; contributes to SYS-01.

SW-03 [Software; conditional draft — decisions pending]: If physical confirmation is absent 10 seconds after dispatch, the app shall display Outcome unknown and shall not automatically retry. Illustrative assumption: the 10-second timeout requires validation.
Sources: SCN-01; DEC-02, DEC-04; contributes to SYS-01.

SW-04 [Software; conditional draft — decisions pending]: Before dispatching an unlock command, the access service shall recheck the resident’s grant for the door and deny dispatch if the grant has been revoked. Post-dispatch revocation remains deferred.
Sources: SCN-01; DEC-01, DEC-05; contributes to SYS-01.

Open review question: How should late, duplicate or out-of-order controller reports be handled?

Deferred boundary: How should revocation after command dispatch be handled?

### Operational Scenarios

#### 1. SCN-01 · Remote unlock
**Goal:** Allow an authorized resident to enter.
**Trigger:** The resident selects Unlock in the app.
**Outcome:** An authorized resident gains access when the controller reports the lock physically unlocked. Request acceptance alone is not confirmation.

### Additional Considerations
- **[assumption]** DEC-01 · Authorization · resolved: Only a signed-in resident with an active grant for this door.
- **[assumption]** DEC-02 · Physical confirmation · resolved: A controller report of the physically unlocked state, correlated to this request.
- **[note]** DEC-03 · Offline behavior · unresolved: Unresolved: What happens when the device is offline?
- **[note]** DEC-04 · Confirmation timeout · unresolved: Unresolved: What happens when confirmation does not arrive?
- **[note]** DEC-05 · Access revocation · unresolved: Unresolved: What happens if access is revoked?

## System Capabilities

### 1. Remote door access
*An authorized resident gains access when the controller reports the lock physically unlocked. Request acceptance alone is not confirmation.*

**Trigger:** Resident requests Unlock

Available package structure inside .ellygent/. This is a file guide, not a generated ZIP for the public sample. Actual content depends on your project and export selection.

manifest.json
Project identifier, live version or baseline identifier, generation time and included content.
project-summary.md
Project overview and links into the selected context.
system-definition.md
Selected system-definition content. Record assumptions and open questions in the source content so they travel with it.
requirements/<specification>.md
Selected specification hierarchy, requirement identifiers, fields and readable relations. Filename depends on the specification.
relations.json
Machine-readable relations between exported objects.
traceability/relationships.json
Optional source-ID → relation type → target-IDs mapping, enabled with --include-traceability.

Sample traceability/relationships.json

Illustrative IDs and relation names in the supported JSON format. In a real project, these must be recorded relationships between elements; source notes in a summary do not automatically create links. A relationship can point to a decision that still needs review.

{
  "SYS-01": {
    "derives": [
      "DEC-01",
      "DEC-02",
      "SCN-01"
    ]
  },
  "SW-01": {
    "derives": [
      "DEC-02",
      "SCN-01"
    ],
    "satisfies": [
      "SYS-01"
    ]
  },
  "SW-02": {
    "derives": [
      "DEC-03",
      "SCN-01"
    ],
    "satisfies": [
      "SYS-01"
    ]
  },
  "SW-03": {
    "derives": [
      "DEC-02",
      "DEC-04",
      "SCN-01"
    ],
    "satisfies": [
      "SYS-01"
    ]
  },
  "SW-04": {
    "derives": [
      "DEC-01",
      "DEC-05",
      "SCN-01"
    ],
    "satisfies": [
      "SYS-01"
    ]
  }
}
Choose an export or CLI workflow

A clearer definition makes the next step easier.

Fewer unresolved decisions entering implementation

Make scope, expected behavior and open questions visible before they become architecture and code.

Less repeated reconstruction of intent

Keep the reasoning behind system and software requirements available to the people building and testing them.

More useful context for coding assistants

Supply selected requirements and system context alongside the implementation task, then review the result against that intent.

A clearer starting point for change

Follow maintained relationships to see what a requirement supports and which connected artifacts may need another look.

Engineering depth when your work needs it.

Keep requirements connected across changes, exchange them with other tools, and add quality or safety analysis where relevant.

AI-Assisted System Context

Use guided definition steps and AI proposals to refine available context. Review and edit proposals before accepting them into your project.

Enterprise Interoperability

Import and export ReqIF requirements to exchange structured specifications with other requirements tools. Check the exchanged content against your toolchain needs.

Traceability Matrix

Create and inspect relationships across specifications. Use the traceability matrix to review coverage and preserve the reasoning behind requirements.

Baseline and Change Control

Save named project snapshots and compare versions to understand what changed. Select a live version or baseline when sharing engineering context.

Requirements Quality Score & AI Review

Request AI feedback on clarity, atomicity and verifiability. Use the findings to refine requirements, with engineers deciding which changes to accept.

Review Workflow with Comments

Collaborative review loops built into the authoring context. Threaded comments link directly to requirements and specifications — keeping systems, software, and QA teams aligned without leaving the tool.

Safety Analysis — ISO 26262 HARA

Use Functional Safety modules to document malfunctions, hazards and safety goals, with severity, exposure and controllability classifications. Engineers remain responsible for the safety analysis.

Context API & CLI Access

Inspect and download selected project context through the Context API and CLI. Supply the files to developers and coding assistants, and refresh them when the definition changes.

Explore all features

Before you start

Ellygent stores structured definition artifacts and relationships so you can see why requirements exist and reuse their context. The goal is to resolve engineering questions and support implementation, not simply produce a longer document.

No. Define enough to address the important uncertainties for the work ahead. Revisit decisions as you learn, and continue exploring and prototyping. The target is avoidable iteration caused by unresolved intent, not useful learning.

Yes. Create or import specifications through supported ReqIF workflows, then identify and document missing objectives, scenarios and system behavior. Engineers recover and connect that upstream context; importing requirements does not recover stakeholder intent automatically.

Keep planning and tracking delivery in your existing tools. Use Ellygent to define expected behavior and the reasoning behind it, then share links or exported context with the people implementing the work. This does not depend on an automatic Jira synchronization.

Review your engineering definition, then use the CLI or Context API to pull selected project context into a local workspace. Supply that context to your coding assistant with the task. Refresh it when the definition changes; the assistant still needs your direction and its output still needs review.

Start with the questions that affect scope and behavior. Lite mode focuses on capabilities and requirements. Engineering mode adds problem framing, objectives, operational context and decomposition when those are needed. Available steps depend on the project mode and modules.

Engineers clarify stakeholder intent, resolve tradeoffs, check proposed artifacts, accept changes and verify the resulting system. AI can help propose or refine content and highlight potential gaps; it cannot know unspoken intent or guarantee correct requirements or code.

Watch the 10-second Ellygent introduction

Explore the engineering behind the workflow

Give your next feature a clearer starting point.

Bring a request or an incomplete specification. Define the missing intent and build connected context for developers and AI.

Create an account, then set up your project and choose the definition steps it needs.