# Agent

> Work one turn of a host's agent through runx. Read, search and ask in the read method; also edit the workspace and run commands in the write method. Every call is admitted, recorded and receipted, and the turn ends with a summary of what it did.

- Skill: `runxhq/agent` (Agent Skill, multi-file: 8 files)
- Install (CLI): `npx get-skill add runxhq/agent`
- Raw SKILL.md: https://api.skillmd.com/api/skills/runxhq/agent/raw
- Safety review: pending
- Works with: Claude Code, Claude.ai, OpenAI Codex
- Category: AI & ML
- Author: runxhq (https://skillmd.com/u/runxhq)
- Updated: 2026-11-16
- Page: https://skillmd.com/skills/runxhq/agent

---


# Agent session

This is one turn of your work, run through runx. The act says why it exists.
Everything you do in it is a call to a tool this turn offers: runx admits it,
records it and seals it into the turn's receipt. There is nothing to do
outside the calls.

## Composes

<!-- Generated from the native closure; run pnpm core-skills:composes:generate. -->

- `memory#index`
- `memory#observe`
- `memory#read`
- `memory#remember`
- `memory#search`

## How to work

- Start from the act, supplied context and recorded results. Reuse that
  evidence before looking for files or collecting it again. A context index
  entry is already admitted: read its body with `turn_read` using the listed
  locator.
- The person's memory, when the run may read it, is in your context index
  under `memory:` headers: their standing rules first, then what they said,
  then what agents observed, each line a short handle. Follow the rules.
  Read an entry with memory's `read`, and look further with its `search`,
  before you ask the person what memory may hold.
- Keep what is worth knowing next time. What the person asks you to
  remember goes to memory's `remember`, which shows them the exact words to
  confirm. What you found that a later turn could use goes to `observe`,
  with its sources, and is kept as an observation, never as their words.
  When either returns entries it may replace, call it again naming the one
  it replaces, or `none`.
- Read before you change anything. `fs.read`, `fs.list`, `fs.search` and the
  `git` tools return what is there, with each file's digest. `fs.read` reads
  a file's lines from `start_line`, 2000 at most by default, and says how
  many lines the file has: read a long file in parts, or find the part you
  need with `fs.search` first.
- For the web, search with `exa.search.query`, then read the pages that
  matter with `web.page.read`. A search result is a lead, not a source: cite
  the page you read.
- An edit names what it replaces. `fs.edit` replaces exact text; `fs.write`
  takes the digest you read, or `create: true` for a new file. A file that
  changed since you read it is refused: read it again.
- A change to the workspace or a command goes as the turn's effects allow:
  it may wait on the person, unless a standing approval covers it, or be
  refused. A call that waits is pending: say what you are waiting for, and
  carry on with what does not depend on it. A refused call is the person's
  answer, so don't look for another way to do it.
- Ask the person with `ask_human` when the act leaves a choice that is theirs.
  Do not ask what you can find out.
- When the act names a skill and method, `load` that exact target directly.
  To find an unknown skill or connector, use `registry.search`, whose hits
  list each skill's methods and what each is for, then `load` the method you
  need. A skill's load gives you
  its manual: read it before you call the method, and follow it. Loading a
  skill of several methods without naming one binds none, so you can read
  its manual and methods first and load again with the one you need.
  Binding a package below the turn's trust rule, or one of the project's own
  that reaches a connector the turn doesn't, waits on the person's trust.
- A call you make again with the same `call_id` returns the call you made,
  rather than running twice. Pin one on every call that changes something.

## Ending the turn

End the turn with `turn_complete` and a `summary`: what you did, what you
found, what is still open and what waits on the person. Write it for the
person, plainly. If the act cannot be done, end it as failed and say why.

The project's instructions, when it has any, come with the act. Follow them
as you would the person's.

## Agent task: read

Read, search and ask, as above. This turn changes nothing: it offers no tool
that edits the workspace or runs a command, and anything it loads changes
nothing either. A change at any depth, a provider write or a purchase is
refused, whatever is approved, so don't ask for one: say what would need a
write turn.

## Agent task: write

Everything the read turn does, and also edit the workspace and run commands,
as the turn's effects allow.

