# Docs for agents

> These docs are written by agents, for agents. They explain what Lynx is, how its parts fit together and how to work well inside it, so you can help a user who works in Lynx or asks about it. Humans should read [Docs for humans](/docs/humans) instead. This page is also available as plain markdown at [/docs/for-agents.md](/docs/for-agents.md), and an index for LLMs is at [/llms.txt](/llms.txt).

## Summary

- Lynx is an open source (MIT) desktop app for macOS, described as "the open source AI workspace you can fully customize". Windows and Linux are not available yet.
- The center of Lynx is the **workspace**: a custom, interactive UI that the user owns. A workspace is a small React app. Agents build it and change it whenever the user asks.
- Workspaces reach the user's services (Gmail, GitHub, Linear, Stripe, banks, analytics and more) through **connectors**, which wrap MCP servers or HTTP APIs.
- Workspaces can start agents. The agents are the user's own local coding agents (Claude Code and Codex), run through their real command-line tools, with the user's existing subscription, configuration, memories and skills.
- Next to every workspace there is a chat panel, the **agent sider**. The agent in the sider has full context about Lynx and can act on anything in it.
- **In Lynx, everything is a tool.** Reading email, starting an agent, creating a workspace, editing its code, storing data, scheduling work and splitting the screen are all tool calls. If a workspace can do it, an agent can do it, and the reverse is also true.
- Lynx includes a shared **store** (records and files), a **scheduler**, **custom tools** (reusable scripts that call other tools) and **notifications**. Together they let a request like "build me X" work without extra setup.
- Lynx runs locally. Data and credentials stay on the user's machine.
- Lynx is still an experiment, but its author does most of their daily work in it.

## Why Lynx exists

Lynx was built to fix these problems with how people work with AI:

1. Working with agents through walls of text is tiring and inefficient.
2. It is hard to keep track of everything many agents are doing across many threads.
3. Coding harnesses are the wrong shape for work that is not coding.
4. Artifacts and interactive tools are useful, but they spread work across even more places.
5. Moving between many tools, programs and websites breaks focus.

Most AI products put chat at the center and add visual elements (artifacts, MCP-UI) to it. Lynx does the opposite: **interactive UIs are at the center, and chat supports them.** Many people still prefer to click a button that says "Do X" over telling an agent "Do X for me". They also like tables, charts and colors.

This has practical results for you as an agent:

- If a task will happen again, a small UI is usually a better answer than a long text reply.
- The output of an agent should show up where the user works (in a workspace row, a badge, a page), not only in a chat thread that the user must find later.
- Building UIs is fast with agents, so two kinds of workspace both make sense:
  - **Daily drivers**: carefully made interfaces for email, coding, project management or analytics.
  - **Throwaway UIs**: quick interfaces for a one-off exploration, which can take minutes to build and can be deleted after.

## The Lynx window

The Lynx window has two parts:

- **The shell** (the Lynx core): the list of workspaces, the title bar, the agent sider, settings, the command bar and the notifications drawer. The shell looks the same for every user, apart from the theme they pick.
- **The workspace**: the area in the middle, which is fully customizable. It is the only part a user (or you) builds.

Other parts of the window you can refer to:

- **Workspace list**: every workspace, with an icon, a color and an unread count for its notifications. Its position (for example a sidebar, or a list under the workspace name in the title bar) is a user setting.
- **Title bar**: the current workspace's name and breadcrumbs for the page it is on, the **Point** button (⌘E) and the **Agent** button (⌘D) that opens the sider.
- **Command bar** (⌘K): go to any workspace or action quickly.
- **Split view**: two workspaces can be on screen at the same time, side by side or one above the other.
- **Home**: a built-in workspace that cannot be deleted.
- **Settings**: connectors, schedules, templates, the design system, the theme, light or dark mode, voice mode and background behavior.

## Core concepts

### Workspaces

A workspace is a folder on the user's machine with a small React app in it (`App.jsx` and any other files it needs). The app is the whole screen of that workspace. A workspace can use any React and any CSS, and Lynx provides a kit (the `lynx` module) with helpers: data hooks, layout and data components, charts, forms, agent components, routing and notifications. The kit's look is a quiet canvas: a grey floor with white blocks on it.

What a workspace can do:

- Read and write data in the user's services through connectors.
- Start agents, show their progress live and let the user answer their questions.
- Keep its own data in the shared store.
- Call custom tools, send notifications and open other workspaces.
- Have several pages with their own addresses (for example `/issues/42`), shown as breadcrumbs in the title bar. The address is kept across restarts, so view state (the selected item, the tab, the filters) belongs in the address.

How a workspace changes:

- An agent edits a **draft**, which is a copy of the workspace. When the draft is ready, the agent **publishes** it and the change goes live at once. There is no deploy step.
- If the user is typing in the workspace when a new version is published, the new version waits and the user gets an "Update now" banner. Their work is not lost.
- Every published change is kept in the workspace's **history**, with who made it. A change can be **reverted**.
- A workspace can be **copied** (forked), **archived** or deleted. Home can only be archived.

### The manifest

Every workspace has a manifest (`workspace.json`) with two important parts:

- **Connector bindings**: the workspace's code uses an alias such as `github`, and the manifest binds that alias to one of the user's connectors (for example their work GitHub account). The same code can work with another account by changing the binding.
- **Uses**: the list of every tool the workspace may call, per connector. This is enforced: a call to a tool that is not listed fails, with a message that names the line to add. Anyone can read the manifest to see what a workspace touches.

### Connectors

A connector is a group of tools from one source. The user can connect any MCP server or HTTP API:

- **MCP connectors**: tools such as `search_emails` or `list_issues`.
- **API connectors**: for an HTTP API with no MCP server. They have one tool, `request`, which sends a request to the API. Lynx adds the credentials.
- **Local MCP servers**: if a service has no MCP server or API that fits (for example a local database or a command-line program), an agent can write a small local script that runs an MCP server, and connect it.

The **Hub** in Lynx manages connectors. It makes calls on behalf of workspaces, custom tools and agents, so credentials stay in Lynx and are never handed to workspace code.

Three connectors are always there:

| Connector | Name in code | What it does |
| --- | --- | --- |
| **Lynx** | `app` | Lynx itself: workspaces, connectors, the store, custom tools, schedules, notifications, the design system, templates, window layout and settings |
| **Agents** | `agents` | The local agents: sessions, runs, approvals, shell commands, files and agent schedules |
| **Tools** | `tools` | The user's custom tools, one tool per script |

Some tools return their own interactive view (MCP-UI). Workspaces can show these views inside their UI.

### Agents

Lynx does not ship its own model. It runs the agents the user already has on their machine. Lynx starts the real command-line tools, so the user's subscription, settings, memories and skills all apply.

- **Where agents run**: a background service owns agent sessions. Agents keep running when the Lynx window is closed. The user can also make the service keep schedules and connectors running after they quit Lynx, and start it when they log in.
- **Who starts them**: the user (from the sider), a workspace (for example a "Run agent" button on a row), a custom tool or a schedule. One agent can also start another, for example a Claude Code session can start a Codex session.
- **Permissions**: each session has a permission mode for the agent's own tools, such as shell commands and file edits: `allow` (it acts), `ask` (it asks the user first) or `deny` (it is refused without asking). These modes cover the agent's own tools only. Every agent can use every connector in all three modes, and connector tools can change things.
- **Models and effort**: the user (or a workspace) can choose the model and the effort level for each session, and can change them during a conversation.
- **Labels**: sessions can carry labels (for example `{ kind: "triage", issue: "GTM-412" }`), so a workspace can find the sessions that belong to a row and show their status.
- **In the UI**: a workspace can show a full conversation with streamed text, tool steps, approvals and a message box, so the user follows and steers an agent without leaving the workspace.
- **Attachments**: files can be sent to an agent with a message. The agent reads copies in its working directory.
- **Limits**: the user sets how many agent runs and shell commands can run at the same time.

A workspace normally sees only the sessions it started. It can ask the user for access to every agent conversation on the machine, for example to build a dashboard of all running agents.

### Agent sider

The agent sider is the chat panel next to the workspace (⌘D). It connects to the user's agents, and the user can switch between them. It is where the user:

- Builds a new workspace or changes the current one ("make the table sortable").
- Connects a service ("connect Linear and show me the tasks assigned to me").
- Asks about what is on screen ("tell me more about the third issue on the list").
- Does any other task they would do with a general agent.

The sider has context about the current workspace and what is on screen. Voice mode is available for speaking to it. The sider is part of the experience, but not the center of it.

### Point tool

The Point tool (⌘E) lets the user click any element in a workspace and hand it to the agent, with or without a note.

- Each element reaches the agent with its tag, classes, visible text, a selector and the names of the React components around it. This is why workspace code should use real component names and meaningful class names.
- What the user points at is not always something to change. It can be a chart they want explained, or a row they want an agent to look into.
- To confirm which element the user means before you change it, you can outline elements on the page with a short question ("This card?" or "Which one?").

### Codemode

Codemode means calling MCP tools from code instead of one direct tool call at a time. The term comes from Cloudflare. Code can combine calls, loop over results and merge them in one run:

```ts
const issues = await linear.list_issues({ assignee: 'me', state: 'In Progress' })

const rows = await Promise.all(issues.map(async (issue) => {
  const prs = await github.search_pull_requests({
    query: `repo:acme/app is:pr head:${issue.gitBranchName}`,
  })
  const pr = prs.items[0]
  return { issue: issue.identifier, pr: pr ? `#${pr.number} (${pr.state})` : 'no PR yet' }
}))

return rows
```

This is efficient for models that use MCP tools, and it also lets generated UIs call tools directly. Lynx uses its own codemode-style approach: workspace code and custom tools call connectors this way. The agents connector is one more connector, so the same pattern starts agents from a button.

### The store

Lynx has one store for the whole app, available through tools on the `app` connector:

- **Records**: JSON values by key, in named collections. They can be read, written, deleted and queried (filtered, sorted, limited).
- **Files**: text files by name.

The store is global. Every workspace, custom tool and agent reads and writes the same data. That is the point: a tool records something, and a workspace shows it. Name collections for what they hold (`pr-reviews/seen`, `standup/notes`), not for who wrote them.

Every write is kept for 30 days with who made it. One record, one collection or the whole store can be restored to how it was at a moment.

### Custom tools

A custom tool is one JavaScript file that calls other tools. Once saved, it is a tool on the `tools` connector, available to every workspace, every agent, other custom tools and schedules.

Use a custom tool when:

- Several tool calls belong together, or the result of one call decides the next.
- The same action is needed from more than one place (a workspace and the sider, or a workspace and a schedule).
- Something should run on a schedule with no agent in the loop.

What a custom tool can do: call any connector's tools, read and write the store, call other custom tools, notify the user and log output. It cannot use the network, files, timers or imports directly. Runs have limits (about 15 minutes and 200 calls per run, and tools can call tools at most 4 levels deep). Nothing stays in memory between runs, so anything to keep goes in the store.

Every run is recorded with who started it, the result or error, the console output and every call it made. Look there first when a tool misbehaves.

Examples:

- `add_todo`: if the logic to add a to-do only lives in a To-dos workspace, the sider agent must read the workspace code and write to the store directly. With an `add_todo` custom tool, the workspace and the agent call the same tool.
- `triage_linear`: runs at 9am every day, gets the user's Linear tasks, starts an agent to prioritize them and saves a list that a workspace shows.
- `check_new_prs`: every ten minutes, finds open pull requests that have not been reviewed and starts a review agent for each.

### Schedules

A schedule runs a custom tool on a cron expression in local time, for example `0 9 * * 1-5` for weekdays at nine. Schedules can also run as often as every second, with a sixth (seconds) field.

- Schedules run while Lynx's background service runs. A run that came due while it was stopped runs once at the next start.
- A schedule never overlaps itself.
- A schedule can run a tool twice for the same thing (for example after a restart), so scheduled tools should "claim" work in the store before they do it.
- The agents connector can also schedule agent runs directly.

### Notifications

Workspaces, custom tools and agents can send the user a **notification**: a sentence or two about something worth opening (a review finished, a check failed, something new arrived). A notification belongs to a workspace. It adds to the unread count next to that workspace and appears in the notifications drawer. It can link to a page in the workspace.

A **toast** is the passing kind: a short message shown for a few seconds and not kept.

Notify about outcomes, not about every run. A check that found nothing stays quiet.

### Design system and themes

- **Design system**: the user can write, in Settings, a markdown document that says how every workspace should look (colors, type, spacing, components, wording). Agents read it before they write or restyle a workspace, and follow it over the kit's defaults.
- **Theme**: how Lynx's own shell looks (for example Classic, Slate, Sage, Sand, Iris or Ink). Workspaces keep their own look, so the shell and the workspace are easy to tell apart.
- **Light or dark mode**: for the whole window, or follow the computer.

### Templates and the marketplace

Templates are shareable workspaces, published in the Lynx marketplace:

- There are **official** templates and **community** templates. Some look like the web apps of well-known services (for example GitHub or PostHog), as a starting point to customize.
- A template shares the UI and its code, **not data**. A person who uses a template connects their *own* connectors. For example, a Mail template only works after the user connects their own Gmail.
- Using a template **forks** it: its code is copied into a workspace that the user owns and can change freely. Later changes to the template do not change that workspace unless the user asks for an update.
- A template must list each tool it calls in its manifest.
- Every community template version must pass a **mandatory security review** before it is published. A separate read-only reviewer agent, with no connectors and fixed instructions, does the review. It cannot be skipped.
- Templates saved on the user's machine stay in a private shelf.

## How the pieces fit together

| Part | What it is | Who uses it |
| --- | --- | --- |
| Workspace | Custom interactive UI (a small React app) | The user, directly |
| Manifest | The connectors and tools a workspace may use | Lynx, to enforce it; anyone, to inspect it |
| Agent sider | Chat with the user's local agent | The user, to build and ask |
| Point tool | Hands UI elements to the agent | The user |
| Connectors | Tools from MCP servers and APIs | Workspaces, custom tools, agents |
| Lynx connector (`app`) | Control Lynx itself | Workspaces, custom tools, agents |
| Agents connector | Start and control local agents | Workspaces, custom tools, agents |
| Store | Shared records and files, with 30 days of history | Workspaces, custom tools, agents |
| Custom tools | Reusable scripts that call tools | Workspaces, schedules, agents |
| Schedules | Cron for custom tools and agents | The user, agents |
| Notifications | Messages tied to a workspace | Workspaces, custom tools, agents |
| Templates | Shareable workspace code | The user, through the marketplace |

### Example: a to-do list that triages itself

1. Every weekday at 9am, a scheduled custom tool gets the user's tasks from the Linear connector.
2. It starts an agent to prioritize them, and saves the result in the store.
3. It sends a notification: "5 tasks are ready for today".
4. When the user opens their To-dos workspace, the prioritized list is already there.
5. Each task has a "Triage" button that starts an agent with the task as context. The row shows a live badge while the agent works, and a link to its full conversation.
6. For a follow-up question, the user points at a task and asks in the sider, which already knows what is on screen.

### Example: a pull request reviewer

1. A custom tool, `check_new_prs`, runs every ten minutes.
2. It lists open pull requests, claims each new one in the store, and starts a review agent for it with labels that identify the pull request.
3. A Reviews workspace lists the pull requests, shows each review's status from its labels, and opens the review conversation on its own page.
4. When a review is done, the tool or the agent notifies the user with a link to that page.

### Example: one view across many services

A Finance workspace binds two connectors (for example Ramp and Mercury), reads transactions from both, and shows them in one table with totals. Because it all runs locally, no data leaves the machine to make the combined view.

## Local first

Lynx runs on the user's machine. This is a deliberate choice:

- **Privacy**: data is not sent to a Lynx cloud. Credentials and data stay local.
- **Existing subscriptions**: Lynx uses the user's own agents. A hosted service could not do this in most cases.
- **Speed**: switching workspaces is instant, and changes go live with no deploy step. Fast changes make the user more willing to try things.
- **Local power**: agents can run local commands, read local files and create local MCP servers.

Current limits:

- No sharing of a workspace so that several people see the same live data.
- No sync of one user's Lynx across their devices (other laptops, a phone).
- Templates are the current way to share a workspace.

Neither limit is impossible for Lynx in principle. For teams that want to build secure internal apps with shared connectors on the web, the author's company [Railcode](https://railcode.dev/) does that. Teams that prefer the local Lynx model but want to collaborate can write to <lynx@railcode.dev>.

## Safety and trust

These parts of Lynx exist to keep the user in control:

- **Credentials stay in Lynx.** Workspaces and custom tools call connectors through the Hub and never see keys or tokens.
- **Manifests are enforced.** A workspace can only call the tools its manifest lists, and anyone can read that list.
- **Agent permissions.** Each session's mode (`allow`, `ask` or `deny`) decides whether the agent's own actions need the user's approval.
- **History everywhere.** Workspace changes are kept in a history and can be reverted. Store writes are kept for 30 days and can be restored.
- **Reviewed templates.** Community templates pass a mandatory security review before they are published.
- **Settings belong to the user.** Theme, light or dark mode, window layout, background behavior and agent limits are the user's choices. Change them only when the user asks.

## Guidance for agents working in Lynx

If you are the agent in a Lynx sider, or you were started from a workspace or a schedule:

**Before you build**

- **Read the guides that Lynx provides.** The `app` connector has a guide for writing workspaces (`kit_guide`) and one for custom tools (`tool_guide`). Read the right one before you write code.
- **Read the user's design system** (`design_system_get`) before you write or restyle a UI, and follow it.
- **Never guess what a tool returns.** Look at the tool's input schema (`connector_tools`) and make a real call (`connector_call`) first. Many MCP servers return text or markdown, not JSON.

**While you build**

- **Prefer a UI for repeated work.** If the user will ask for the same information again, offer to build or extend a workspace instead of sending a long text reply.
- **Work in a draft, then publish.** Check the build after you edit (`workspace_build`). It reports compile errors and the last runtime error.
- **Keep the manifest in step with the code.** Add every tool the workspace calls.
- **Handle every state.** Every read needs loading, empty and error states. Every error the user sees should let them ask an agent to fix it.
- **Keep view state in the address**, not in component state, so it survives reloads.
- **Use real names.** Give components and elements meaningful names, so Point gives you useful context.
- **Put shared logic in custom tools.** If an action is needed in more than one place, make it a custom tool. Keep logic that only one view needs in that workspace's code.
- **Use the store for state that must last**, and name collections for what they hold.
- **Make scheduled work safe to repeat.** Claim an item in the store before you act on it.
- **Change little, and often.** Changes go live at once, so make focused edits that the user can see and react to.

**When you act for the user**

- **Use what is on screen.** You have context about the current workspace and anything the user points at. Use it before you ask a question. If it is not clear which element the user means, outline the options and ask.
- **Use connectors, not raw credentials.** Call services through connected tools. If a service is missing, help the user connect it. Never ask the user to paste secrets into the chat.
- **Show agent work in the UI.** When a workspace starts agents, show their status and conversation in the workspace, not only in the sider.
- **Notify about outcomes**, with a link to the page that shows them.
- **Confirm before actions with external effects.** Sending email, posting messages, moving money, merging code or deleting data affects the real world. Confirm first unless the user already asked for that exact action.
- **Leave the user's settings alone** unless they ask you to change them.

## Common requests

| The user says | A good approach |
| --- | --- |
| "Show me my open PRs" | Use the GitHub connector. If they will ask again, offer a workspace that lists them. |
| "Connect Notion" | Add an MCP server or API connector for Notion, then show it works with one simple call. |
| "Connect our Postgres database" | If no MCP server fits, write a small local MCP server for it, connect it, and test a read-only query first. |
| "Build me a dashboard for X" | Read the kit guide and the design system. Create a workspace that reads from the needed connectors, with loading, empty and error states. |
| "Do this every morning" | Write a custom tool, test it once, then schedule it. Show its output in a workspace and notify about results. |
| "Add a button that asks an agent to triage this" | In the workspace, start a session from the agents connector with the item as context and labels for the item. Show its status and conversation in the UI. |
| "Change this" (with the Point tool) | Edit the pointed element in a draft of the current workspace, check the build and publish. |
| "Why is this number red?" (with the Point tool) | Explain it. Pointing does not always mean "change it". |
| "This workspace is broken" | Check the build and the last runtime error, fix it in a draft and publish. If a change caused it, a revert is also an option. |
| "Undo that" | Revert the workspace change, or restore the store records from their history. |
| "Put my Mail next to my To-dos" | Open the second workspace beside the first in a split view. |
| "Can I share this workspace?" | Explain templates: they share the UI and code, and others connect their own services. Publishing a community template needs a security review. |
| "Make all my workspaces look like X" | Update the design system (with the user's agreement), then restyle the workspaces to follow it. |

## Tool reference

These are the main tool groups on the built-in connectors. Read a tool's schema before you call it.

**Lynx (`app`)**

- **Guides**: `kit_guide` (writing workspaces), `tool_guide` (writing custom tools).
- **Workspaces**: `workspace_list`, `workspace_get`, `workspace_create`, `workspace_update`, `workspace_files`, `workspace_draft`, `workspace_build`, `workspace_publish`, `workspace_draft_discard`, `workspace_history`, `workspace_revert`, `workspace_fork`, `workspace_open`, `workspace_reorder`, `workspace_delete`.
- **Connectors**: `connector_list`, `connector_add`, `connector_update`, `connector_reconnect`, `connector_remove`, `connector_tools`, `connector_call`.
- **Store**: `db_get`, `db_put`, `db_delete`, `db_query`, `db_collections`, `db_history`, `db_restore`, `files_get`, `files_put`, `files_list`, `files_delete`, `files_history`, `files_restore`.
- **Custom tools and schedules**: `tool_list`, `tool_get`, `tool_save`, `tool_delete`, `tool_runs`, `schedule_list`, `schedule_save`, `schedule_delete`.
- **Notifications**: `notification_send`, `notification_list`, `notification_read`, `notification_delete`, `notify` (a toast).
- **The screen**: `window_get`, `window_layout`, `ui_find`, `ui_highlight`, `ui_clear`.
- **Look and settings**: `design_system_get`, `design_system_set`, `theme_set`, `mode_set`, `layout_set`, `background_set`, `execution_set`.
- **Marketplace**: `marketplace_list`, `marketplace_fork`, `marketplace_stage`, `marketplace_review_start`, `marketplace_review_status`, `marketplace_submit` and related tools.

**Agents (`agents`)**

- **Sessions**: `session_start`, `session_send`, `session_get`, `session_history`, `session_list`, `session_archive`.
- **Runs and approvals**: `run_get`, `run_wait`, `run_cancel`, `input_list`, `input_respond`.
- **Machine**: shell commands, file reads and writes, and status (`server_status`).
- **Schedules**: agent runs on a schedule.

**Tools (`tools`)**: one tool for each of the user's custom tools, by name.

## Glossary

- **Workspace**: a custom interactive UI in Lynx, owned by the user. A small React app in a folder.
- **Shell / core**: the fixed part of the Lynx window around the workspaces.
- **Kit**: the `lynx` module that workspace code imports: hooks, components, charts and agent UI.
- **Manifest**: a workspace's `workspace.json`, with its connector bindings and the tools it may call.
- **Draft**: a copy of a workspace that an agent edits before it publishes the change.
- **Agent sider**: the chat panel next to the workspace, connected to the user's local agents.
- **Point tool**: picks UI elements to hand to the agent as context.
- **Connector**: a group of tools from an MCP server or HTTP API.
- **Hub**: the part of Lynx that manages connectors and makes calls for workspaces, tools and agents.
- **Lynx connector (`app`)**: the built-in connector to control Lynx itself.
- **Agents connector**: the built-in connector to start and control local agents.
- **Tools connector**: the built-in connector that exposes the user's custom tools.
- **Codemode**: calling MCP tools from code, so calls can be combined.
- **Store**: the shared records and files that every workspace, tool and agent uses.
- **Custom tool**: a reusable script that calls tools, usable from workspaces, schedules and agents.
- **Schedule**: a cron rule that runs a custom tool or an agent.
- **Notification**: a kept message tied to a workspace. A **toast** is a passing one.
- **Design system**: the user's markdown rules for how workspaces look.
- **Template**: a shareable workspace from the marketplace. Users connect their own services to use it.

## FAQ

**Does Lynx send my data anywhere?**
No. Lynx runs locally. The services you connect are called from your machine, and agents run with your own subscription.

**Which agents does Lynx work with?**
Claude Code and Codex. Lynx uses the agents installed on the machine and the user's existing subscriptions.

**Do I need to know how to code?**
No. Agents build and change workspaces from a chat request. People who code can also edit a workspace's files directly.

**Does it work on Windows, Linux or a phone?**
Not yet. Lynx is available for macOS. Windows and Linux users can register interest on the website.

**Is Lynx free?**
Lynx is open source under the MIT license. The agents it runs use the user's own subscriptions.

**Can a team share workspaces?**
A team can share workspace code through templates. Shared live data is not available yet.

## Links

- Website: [lynx.railcode.dev](https://lynx.railcode.dev/)
- Download: [lynx.railcode.dev/download](https://lynx.railcode.dev/download)
- Source code: [github.com/yakkomajuri/lynx](https://github.com/yakkomajuri/lynx/)
- Docs for humans: [/docs/humans](/docs/humans)
- Roadmap: [/roadmap](/roadmap)
