Agents of your own, a text away
Your own AI, on your computer, that you text from your phone. It answers you and the people you share it with, remembers what you tell it, and can only touch its own folders.
- Text it from your phone, or talk to it here. Telegram, Slack,
Discord or Signal, and it answers you, and whoever is in a chat you
share it with
(Connections); or
lnk agent chat startin a terminal, andlnk agent chat send --message TEXTin a script (Talk to it here). - Choose its harness and its model. Start with Link Harness, or use OpenClaw, Hermes Agent, DeepSeek Harness or any other (Switch Harnesses). Its model can run on your computer or be a provider's (Switch Models).
- It remembers, and works while you're away. It searches its files and conversations (Memory) and the web (Web), and on Link Harness it schedules work for itself and messages the rest of its team (Scheduler, Make a team).
- It's sandboxed. It changes only its own folders and reaches the internet through a filtering proxy, and you choose what more it may do (Permissions).
- It can move. Run it on a machine in your own cloud, and bring it back (Move Machines).
lnk up agents # the harness and Link Harness plugins, and lnk up models for local ones
lnk agent start # pick a model, then Link Harness starts in the background
lnk agent chat start # talk to it in this terminal
lnk agent connect telegram # text it from your phone, or slack, discord, signal
lnk agent status # whether it runs
lnk agent create work # another agent, with its own files and botWhat it needs
You need a Mac, or a Linux x86-64 computer with bubblewrap installed.
lnk up agents adds the plugins, and lnk up models adds the one for a
model on your computer. That model is free. A hosted model needs a key
from Anthropic, OpenAI or OpenRouter, and the provider bills you.
Start your agent
It keeps running in the background, also after a restart. A harness has
commands of its own, lnk agent harness ..., for your agent's harness
or the one --harness names: link, openclaw, hermes, deepseek
or one you added.
lnk agent start # asks which model, then runs it in the background
lnk agent start --model qwen3 # a model running on this computer
ANTHROPIC_API_KEY=sk-ant-... lnk agent start # a hosted model, its key from the variableThe first start
The first start installs the harness and asks which model your agent
thinks with, which folder it works in, and which of Link's tools it
gets: Memory, picked unless you say otherwise, Web, whose search asks
for a Brave Search or Tavily key, Browser, which needs Chromium or
Google Chrome on this computer, and Desktop, which needs Linux's
Xvfb. Later starts reuse what you chose.
A personal agent
A new agent is a personal
agent:
scheduler, run, file and code are off until you add each one with
lnk agent tool add <name> or enable it in your spec. Add reusable task instructions
through Skills.
Create on a hosting account
lnk agent create work --on <account> makes a blank agent directly on
an account that hosts agents, using its harness and model defaults. It
asks for no model key and makes no local copy. lnk agent list shows
it there; lnk agent connect telegram --agent work connects it through
that account. A box name after --on still creates the agent on the box.
Its tools, asked once
The tools are asked once per agent, whatever you answer, and lnk agent tool add <tool> adds one later. Picking Memory offers its embedding
model too; without it, memory searches by words only.
Without a terminal
Without a terminal to ask in, its folder is ~/Link/Agents/<name>/Home
(--files <dir> picks another), and it says so and names the command
for its tools, and a later start in a terminal asks.
The models it offers
In order: a model already running on this computer, which is free and private; with none, on an Apple Silicon Mac, one to install, a few GB; then an API key from Anthropic, OpenAI or OpenRouter.
What every start shows
Every start ends with the table lnk agent status shows: whether it
runs, its model, its tools, where you text it, and where its files are.
Running means its harness answers; a key the provider refuses shows at
your first message.
A hosted model's key
Give a hosted model's key when lnk asks for it, or as the provider's
variable, as above: never on the command line, which other users of this
machine can see. To change the model later, see
Switch Models. Your agent answers only while its machine
is on.
Talk to it here
Talk to your agent in this terminal, or from a script, with no account or bot.
lnk agent chat start # a conversation in this terminal
lnk agent chat send -m "hello there" # one message and its answer, for a script
lnk agent chat start --chat work # select the named conversation, link:work
lnk agent chat show link:main # the conversation, as you would read it
# the message on stdin, the answer as JSON
echo "hello" | lnk agent chat send --jsonLink's own connection
lnk agent chat start talks to your agent on Link's own connection, link,
with no account or bot: only you, as the agent's user on its machine,
reach it. In a terminal, each answer shows as it's written; Ctrl-C
stops waiting for it, and Ctrl-D or /quit leaves.
Threads and scripts
Each lnk agent chat start opens a fresh conversation, prints its
link:<name> ID, and keeps follow-ups together until you leave. Its
folder is Agent/chats/link-<name>/. Use --chat <name> to select a
particular conversation, including one from an earlier session.
One message from a script
lnk agent chat send takes one message with --message or piped stdin,
prints the answer, and exits nonzero when the agent is stopped, fails
or doesn't answer, so a script can check it. Its default is link:main;
--chat <name> sends to a selected conversation.
Connection threads
Each Discord or Slack thread has its own conversation. Replies in a thread share context; another thread starts separately. Saved memory notes belong to the agent and are available across these conversations.
An answer nobody waited for
An answer nobody waited for in a thread (a reminder it set there, an answer you stopped waiting for) comes at your next chat on it, before your message, or as it comes while a chat is open.
An agent elsewhere
An agent on a box answers from there, and one on a cloud account that hosts agents through that account's adapter (Machines).
Which harness
It needs a harness that answers an endpoint, as Link Harness, DeepSeek Harness, OpenClaw and Hermes Agent do, the last two through Link's bridge. One that speaks only its own connections is refused, saying so: talk to it on a connection instead.
Give it tools
Add Link's tools to your agent, or take them away, one at a time.
lnk agent tool list # each of the tools of Link: whether it has it, and what it needs
lnk agent tool add memory # search over its files and conversations, and notes it keeps
lnk agent tool add web # pages, and a search with a Brave Search or Tavily key
lnk agent tool add browser # a browser of its own: pages opened, clicked, typed into and seen
lnk agent tool add desktop # a desktop of its own, on Linux, where the programs it runs show
lnk agent tool add file # enable file reads and writes within its sandbox grants
lnk agent tool add scheduler # enable subagents and scheduled work
lnk agent tool remove webState is on when the tool is configured for this agent, and off
otherwise. An installed plugin alone does not enable its tool. Scheduler,
run, file and code start off in every profile. add and remove save
their [behavior.tool.<name>] enabled switch in Config/agent.toml, preserving
other opinions and comments. You can also set that switch yourself.
Grant the folders or programs each tool needs in its sandbox file;
only confirming a proposal widens those grants. A request outside them is refused
by the tool; saved memory uses its separate notes permission.
Missing sandbox permissions
Adding a built-in tool displays any missing file or program permissions
and asks before saving them in Config/sandbox.toml. Without approval,
the tool stays off. --yes explicitly approves the displayed proposal.
Existing sufficient grants are reused. Removing a tool switches it off
without revoking grants that another tool may share. Setup and tool
switches live together in Config/agent.toml under [behavior].
add web
add web installs Link Web if it isn't here, and takes its search key
from BRAVE_API_KEY or TAVILY_API_KEY, else asks for it; without
one, your agent fetches pages but doesn't search. The key stays with
Link's sandbox, outside your agent.
A tool of your own
A tool of your own, an MCP server
lnk sandbox tool add defines, is added by its name. Each change
restarts your agent if it's running, and says where it's written:
Link's tools has each one.
See how it's doing
Ask whether your agent runs, and follow what it does.
lnk agent status # whether it runs, with its model, tools, phone, files and sandbox
lnk agent logs --follow # its last lines since the last start, then new ones
lnk agent logs --live # what it does as it does it: messages, thinking, tools, answersstatus says one of five states. running means its harness answers,
and running in a terminal that it runs there, from
lnk agent start --foreground. asleep means it stopped for being
idle and its next message starts it. stopped means it isn't running.
not answering means it runs but its harness doesn't answer, and
lnk agent logs shows why. Asleep and the two running states exit with success, the others with a failure.
--live
--live prints a line a step: a message come, the model thinking, and
each minute it goes on that it still is, a tool called and answered or
failed, the answer with how long it took and its tokens, and the agent
stopping or starting. A slow answer then shows where it waits: on the
model, on a tool, or on nothing. It reads Link Harness's conversations,
so with another harness it shows only starts and stops.
status
status exits nonzero unless the agent answers. When its proxy has
paused its wire, or every wire is stopped, it says so and why. On a box,
where no notification shows, that's where you see it. For other
programs, status --json and list --json are in
contracts.
See what it's told
Print the prompt your agent's model gets, whole or by its sections.
lnk agent show --instructions # the prompt its model gets, exactly as it is sent
lnk agent show --instructions --json # each section, where it came from, its size
lnk agent show scout --json # another agent, as typed blocks like statusThe harness's prompt
Link Harness shows the prompt it assembles from the agent's instruction files, tool descriptions, skills and notes. Link Harness explains its section order, caching and editable sources. A harness from outside Link builds its own prompt, which this command cannot show.
Read its conversations
Read a chat as you would, or move the old ones to the way its spec
keeps them now. Only Link Harness prints and moves its conversations:
on another harness, these commands are refused and name
lnk agent use --harness link.
lnk agent chat show telegram:123456789 # one chat, as you would read it
lnk agent chat show link:main # what you said with lnk agent chat send
lnk agent chat convert # each chat kept the way its spec says nowLink Harness keeps each chat in its files, as a log you can cat, or
smaller, or in a database: its spec's [storage] conversations says
which, for a new chat (how).
lnk agent chat show prints a chat however it's kept; move, with
the agent stopped, moves the old ones to the way the spec says now.
Make a team
A team splits a job by purpose: each agent keeps its own model, connections and files, sends the others messages, and shares a folder with them.
lnk agent team create research --agent scout --agent writer --agent checker # each writes the folder they share
lnk agent team add research --agent checker --purpose "checks every claim" --read . --write notes
lnk agent team list # who is on it, and what each reaches
lnk agent team show research --member scout --json # one team, or one member, as typed blocks
lnk agent team remove research --agent checker
lnk agent harness check --harness link --agent scout # it reads the folder of its team, no otherMessages between them
On Link Harness a member sends another a message with its scheduler, and the answer comes back as a message from that agent, never from you. The scheduler's caps stop two that keep answering each other. You talk to each member on its own connections.
Its folder
The team's folder is ~/Link/Teams/<team>/Shared, and each member reaches
only what it's granted of it, and no other team's.
Its memory
The team also brings
a memory over that folder, one server for the members granted all of
it (.), on Link Memory: when that isn't on the machine, a member's
start says so before installing it, and asks first in a terminal.
Its file
Its file,
~/.lnk/teams/<team>.toml, holds the members and the
opinions they share,
and each change restarts the members that run.
Invite an agent from another account
On a cloud that hosts teams across accounts, both owners agree:
lnk agent team invite design --cloud my-cloud --agent acct-bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb/k3m4n5p6q7r8 --as reviewer --read . --write notes
lnk agent team join design --owner acct-aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa --cloud my-cloud --agent reviewer
lnk agent team leave design --owner acct-aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa --cloud my-cloud --agent reviewer
lnk agent team remove design --cloud my-cloud --agent reviewerJoining
The invitation names the other account's permanent agent ID. The invited
agent's owner runs join using the agent's own hosted name or ID. Until
then it receives neither messages nor the folder.
Leaving
Either owner can end membership: the invited agent's owner uses leave; the team's owner uses
remove. The hosting cloud refreshes active bindings when membership
changes. lnk agent team list includes hosted teams; append @<account>
when more than one account has that team name.
Its folder bounds
The team's owner chooses the invited agent's folder bounds. Its owner's consent remains in force when that team owner later changes the file, including those bounds; removing and reinviting it requires fresh consent.
Who reads what
Whoever can talk to a member can cause it to read the files it can reach. An outside agent's owner can read what it read in its conversations.
Stop it
Stop your agent and everything started for it, until it starts again.
lnk agent stop # lnk agent start starts it again, with the same settings
lnk agent restart # stop completely, then start again in the backgroundNormal lnk agent start also registers automatic startup. On macOS,
launchd keeps it running and starts it at your next login after reboot.
On native Linux it enables the user service. lnk agent stop removes
that automatic startup as well as stopping it now. restart applies
stop and start to an existing agent; it keeps its saved model, files
and tool configuration. --agent <name> selects another agent.
In a terminal
One started with --foreground is running in a terminal to
status, and stops with Ctrl-C there, lnk agent stop, or a SIGTERM or
SIGHUP to lnk, which it passes on to the harness and waits for (one
asleep for being idle just ends). On Linux, lnk killed outright
(SIGKILL) sends its harness a SIGTERM all the same, so nothing it
started keeps the agent's ports. Until then another lnk agent start
says it runs there. Its output shows there and goes to its log too, as
a service's does, so lnk agent logs reads it either way.
What a stop ends
A stop ends everything started for the agent, however it runs (in a terminal, as a background service, or woken when a message comes): its harness, its bridge and connections, its scheduler's runner and the calendar's wake, and its background commands. Nothing of it fires a job or answers a message until it starts again.
Remove an agent
Remove an agent, keeping its files or not.
lnk agent delete work # asks first, then whether its files go too
lnk agent delete work --yes # without asking, and its files are kept
lnk agent delete work --yes --delete-files # and its files go tooWhat goes
remove stops the agent and deletes its settings, its harnesses with
their installs, memory and conversations, its log, its keys, its
sandbox rules and its memory's and scheduler's tools.
Its files
Its files (its
Home and its own folder, with its instructions, skills, conversations,
memory's index and scheduled jobs) go only if you say so; kept, they're
moved to ~/Link/History/Agents/<name>-<date> for 30 days, and a Home
you chose yourself stays where it is. Its buckets stay in your clouds,
so lnk agent restore work brings it back, asking for their password.
What stays
What lnk measure recorded of it stays until it ages out. It leaves
every team it was on, and the teammates that run restart to take that.
With one agent left, commands act on it without --agent.
Where things live
Your agent's files, its harness and its log each have a folder of their own.
~/Link/Agents/<agent>/Homeholds your agent's files.lnk uninstallkeeps them unless you pickagents.~/Link/Agents/<agent>/Harnesses/<name>is a harness's home, with its install, memory and conversations.~/.lnk/agents/<agent>/logs/holds its log.
Everything else Link keeps for an agent, and who can reach it, is in Security.
More about it
When it doesn't start or answer, see Troubleshooting.
Every flag is in lnk agent <command> --help. Security
has the guarantees and gaps, and Decisions why it works
this way. To add a harness, see
Write a Plugin.
Action namespaces
Action namespaces connect its commands, tools, routes and namespace CLI actions.
Docs
- Move Machines: Move your agent to a box in your own cloud, and back, with everything it knows
- Switch Harnesses: Change what runs your agent in one command, and back
- Decisions: Why bringing an existing agent under Link copies its state and rewrites paths in the forms that own them
- Troubleshooting: What to do when switching harnesses goes wrong, one symptom to a heading
- Switch Models: Change what your agent thinks with, in one command
- Interface: What other programs can rely on from
lnk agent: its commands' output, the commands a move runs, and what other plugins ask of it - Action namespaces: An agent's actions have the same names across its surfaces: a command is
/task:run, a tool istask__run, and a route is/_link/task/run - The Bridge: What
lnk agentruns beside an agent's harness to carry its connections and serve Link's tools, as the connection contract types them - Decisions: Why agents work the way they do
- Security: What each part of an agent is kept from reaching, starting with the harness that runs it
- Troubleshooting: What to do when your agent doesn't install, start, stay running or answer (Agents)
- Configuration: The files
lnk agentkeeps for this machine and for each agent, and what each one holds - Agent Files: Every file
lnk agentkeeps for an agent, its harness and its moves, and what each one holds (Configuration) - Skills: Skills give your agent reusable instructions for a kind of task