Install the CLI
curl -fsSL https://download.crystallattice.dev/crystal-lattice-cli/install.sh | bash
curl -fsSL https://download.crystallattice.dev/crystal-lattice-cli/install.sh | bash
Crystal Lattice is a model-native agent platform: the harness changes around the model, including its system message, tool schema, request behavior, provider-native state, and UI controls. Built-in plugins provide Codex, Claude, Gemini, Qwen, Kimi, and Grok-style defaults, and your config can replace them.
curl -fsSL https://download.crystallattice.dev/crystal-lattice-cli/install.sh | bash pipx install crystal-lattice-cli Built-in model-family harnesses
Computer to phone
Start Crystal Lattice in the project folder where you want the agent to work. The terminal UI can stay open, but the work is not trapped there: the app UIs can open the same sessions and watch responses stream.
On the same Wi-Fi, Crystal Lattice Control can find your computer automatically. Choose Automatic Discovery, select your computer, and continue the same workspace from your phone.
Automatic discovery uses the local network. If your phone is outside that network, use the bridge section below.
curl -fsSL https://download.crystallattice.dev/crystal-lattice-cli/install.sh | bash
curl -fsSL https://download.crystallattice.dev/crystal-lattice-cli/install.sh | bash
mkdir -p ~/crystal-lattice-demo
cd ~/crystal-lattice-demo
crystal-lattice \
--server \
--console \
--config-local \
--host 0.0.0.0 \
--port 9000 \
--enable-bonjour
mkdir -p ~/crystal-lattice-democd ~/crystal-lattice-democrystal-lattice \--server \--console \--config-local \--host 0.0.0.0 \--port 9000 \--enable-bonjour
Open Crystal Lattice Control, choose Automatic Discovery, and select your computer.
Show computer runtime on the left and terminal, desktop app, mobile app, and custom UI connected to the same sessions.
Outside your local network
Hosted bridge service is coming soon. Today, when your phone is not on the same network as your computer, deploy your own bridge and pair through it.
The bridge gives Crystal Lattice clients a way to reconnect from outside the local network. Local bridge hosting is useful for development and testing, but production use should deploy the bridge somewhere reachable.
ALLOW_AWS_DEPLOY=1 deploy/aws-ec2/build.sh \
--profile secure \
--stack-name crystal-lattice-bridge \
--region us-east-1
ALLOW_AWS_DEPLOY=1 deploy/aws-ec2/up.sh \
--profile secure \
--stack-name crystal-lattice-bridge \
--region us-east-1
ALLOW_AWS_DEPLOY=1 deploy/aws-ec2/build.sh \--profile secure \--stack-name crystal-lattice-bridge \--region us-east-1ALLOW_AWS_DEPLOY=1 deploy/aws-ec2/up.sh \--profile secure \--stack-name crystal-lattice-bridge \--region us-east-1
crystal-lattice \
--server \
--console \
--config-local \
--host 0.0.0.0 \
--port 9000 \
--bridge-url wss://<your-cloudfront-domain>/ws/websocket
crystal-lattice \--server \--console \--config-local \--host 0.0.0.0 \--port 9000 \--bridge-url wss://<your-cloudfront-domain>/ws/websocket
Open Crystal Lattice Control, choose Bridge Service, enter the bridge URL, select your computer, and enter the pairing code.
Show phone -> bridge -> user's computer, with pairing code callout.
Model-native harnesses
Model-native means Crystal Lattice changes the harness around the model: system message, tool schema, request behavior, provider-native state, and UI controls. The built-in defaults do this with plugins, and those plugins can be replaced.
| Model family | Built-in harness | What changes |
|---|---|---|
| Codex / GPT coding models | codex-tools | Codex-style shell tools, apply patch semantics, skills block, model-family system instructions. |
| Claude | claude-tools | Claude-oriented tool schema and workflow conventions. |
| Gemini | gemini-tools + compaction plugins | Gemini-oriented system message and tool behavior, optional compaction flow. |
| Qwen | qwen-tools | Qwen-oriented tool and instruction style. |
| Kimi | kimi-tools | Kimi-oriented tools and prompt behavior. |
| Grok | grok-tools | Grok-oriented tools and request behavior. |
| OpenAI Responses | openai_responses | Responses-native reasoning, usage/cost metadata, attachments, prompt caching, native compaction. |
| OpenRouter | openrouter | OpenRouter model routing, reasoning/web/image extensions depending on provider path. |
Codex / GPT coding models
codex-tools
Codex-style shell tools, apply patch semantics, skills block, model-family system instructions.
Claude
claude-tools
Claude-oriented tool schema and workflow conventions.
Gemini
gemini-tools + compaction plugins
Gemini-oriented system message and tool behavior, optional compaction flow.
Qwen
qwen-tools
Qwen-oriented tool and instruction style.
Kimi
kimi-tools
Kimi-oriented tools and prompt behavior.
Grok
grok-tools
Grok-oriented tools and request behavior.
OpenAI Responses
openai_responses
Responses-native reasoning, usage/cost metadata, attachments, prompt caching, native compaction.
OpenRouter
openrouter
OpenRouter model routing, reasoning/web/image extensions depending on provider path.
Native provider features
Some capabilities are not generic chat settings. Reasoning effort, verbosity, web search, prompt caching, native compaction, attachment handling, usage, and cost metadata depend on the provider path.
Crystal Lattice lets provider and feature plugins expose those controls and outputs directly to the UI, so native behavior is visible instead of hidden behind a generic wrapper.
placeholder-needed
Expose model-specific controls when the provider supports them.
placeholder-needed
Show search/citation behavior through provider extensions where available.
placeholder-needed
Keep long sessions practical with provider-native cache and compaction controls.
placeholder-needed
Surface metadata, generated assets, and attachment handling in the UI.
Everything is replaceable
Crystal Lattice treats that as normal. Providers, provider extensions, features, tools, application actions, session behavior, and UI elements are all plugin surfaces.
The built-in plugins give you useful defaults. Your own plugins can replace the parts your workflow disagrees with, and config can point at those plugins without waiting for upstream approval.
Code examples are illustrative placeholders, not final API.
Add native support for a model API.
# Placeholder example, not final API.
class MyProvider:
name = "my_provider"
def to_native_messages(self, messages, state, *, context=None):
return convert_to_my_api(messages)
def stream_api(self, native_messages, state):
yield from call_my_model(native_messages, state)
Surface provider metadata, reasoning, citations, or UI fields.
# Placeholder example, not final API.
class UsageFooter:
name = "usage_footer"
def finalize(self, final_messages, native_messages, state):
return add_usage_metadata(final_messages, state)
def get_ui_elements(self, config, context=None):
return [
{"ui_type": "message_footer", "data": "metadata.total_cost"}
]
Transform context, request behavior, or final messages.
# Placeholder example, not final API.
class ProjectContext:
name = "project_context"
def to_native_messages(self, messages, native_messages, state):
return inject_project_context(native_messages)
Expose Python, Node, Bash, or MCP-backed capabilities.
# Placeholder example, not final API.
class SearchTickets:
name = "search_tickets"
def get_tool_schemas(self, state):
return [ticket_search_schema]
def execute_tool(self, tool_name, payload, state):
return search_linear_or_jira(payload)
Add session-level workflow actions.
# Placeholder example, not final API.
class CreateReleaseNotes:
name = "release_notes"
def get_actions(self, state):
return [
{
"id": "release_notes.create",
"label": "Create release notes",
}
]
def execute_action(self, app, action_id, params, context, state):
return create_release_notes(app, params)
Render settings and actions in app UIs without hardcoding them.
# Placeholder example, not final API.
def get_ui_elements(self, config, context=None):
return [
{
"ui_type": "session_action",
"label": "Sync down",
"action_id": "cloud.sync_down",
},
{
"type": "select",
"key": "reasoning_effort",
"label": "Reasoning effort",
},
]
Session workbench
Agent work is more than a transcript. Built-in session plugins turn conversations into durable workspaces with titles, pinned state, summaries, snapshots, attachments, ordering, and session actions.
The workbench is plugin-driven too: built-in plugins provide the default behavior, and your own plugins can add or replace workflow actions.
/session-list-workbench.png
Titles, pinned state, ordering, message counts, and timestamps.
/chat-actions-workbench.png
Message and session actions exposed by plugins.
/session-snapshots-workbench.png
Create, inspect, select, and restore session checkpoints.
/session-attachments-workbench.png
Preserve generated assets and session-owned files.
/session-settings-plugins.png
Per-session controls from plugin UI schema.
Plugin authoring
A user-owned plugin workflow still needs product polish, but the design goal is straightforward: inspect the docs, pick the right plugin type, copy the closest template, write tests, and load the plugin from config.
I want to build a Crystal Lattice plugin.
Please inspect the plugin documentation in this repository, especially:
- plugins/docs/index.md
- plugins/docs/tool-plugins.md
- plugins/docs/application-plugins.md
- plugins/docs/provider-plugins.md
- plugins/docs/provider-extensions.md
- plugins/docs/feature-plugins.md
- plugins/docs/ui-elements.md
- plugins/docs/plugin-packaging-and-loading.md
Goal:
Create a plugin that [describe what I want].
Please:
1. Identify whether this should be a provider, provider extension, feature, tool, or application plugin.
2. Find the closest existing plugin or template to copy from.
3. Explain what UI, if any, the plugin should expose.
4. Propose the file layout.
5. Draft an implementation plan.
6. Tell me what tests should be added before coding.
{
"plugins": [
"path:./plugins/my-custom-plugin"
]
}
Python SDK
When the work becomes repetitive, use the same configured agents and plugins from Python. The example below sketches a short sales-letter workflow over a CSV of leads.
The final webpage should verify this against the current SDK and may add a small helper if the public API needs a simpler "run until final" path.
sdk-api-needs-verificationimport pandas as pd
from agent_app import AgentApplication
app = AgentApplication.from_config("./.crystal/config.json")
leads = pd.read_csv("leads.csv")
def draft(row):
session = app.create_session(agent_id="codex-openrouter")
app.add_message(
session.session_id,
"user",
f"""
Write a concise first sales email.
Name: {row.name}
Role: {row.role}
Company: {row.company}
Notes: {row.notes}
""",
)
result = app.run_until_final(session.session_id)
return result.content
leads["draft"] = leads.apply(draft, axis=1)
leads.to_csv("drafts.csv", index=False)
Start with built-in model-family plugins, run Crystal Lattice on your computer, continue from phone or app UI, and replace the parts of the harness your workflow disagrees with.