agent

harness install agent

The optional agent package owns identity, multi-turn dialogue, long-context compression, private memory and conversation history. The Harness core independently performs natural-language tasks, benchmark episodes and learning; it never imports this package.

harness run "Fix the parser and verify the regression" --folder ./project
harness agent --identity work --folder ./project
harness agent "Remember that PRs must be in English" --identity work --json
harness agent "Continue our discussion" --identity work --session SESSION_ID
harness agent --identity work --show-memory

harness without a command opens this optional agent. harness run never installs it. Agent instances live under $HARNESS_HOME/agents/<identity>. Each contains an identity configuration, private memory, sessions and a separate learning library. A session stores raw dialogue events plus a bounded working context and explicit summary. New sessions retain private memory but do not silently concatenate previous conversations; history search is an explicit agent action. Independent identities share nothing by default.

The default identity imports legacy Personalization text once on first creation. Legacy workspace libraries and historical run traces remain untouched; use --library PATH to bind an old library explicitly. To edit persistent instructions, edit the identity's identity.json while its sessions are idle. Package upgrades do not rewrite this data.

The agent handles ordinary dialogue itself and submits complete tasks through Host.task. Tasks keep their own program/controller loop, budget, evidence and resource cleanup. Agent dialogue calls and each task's usage are recorded separately. A finished task is not automatically a verified success. Learning writes the separate library only when explicitly enabled; remembering a preference does not activate executable code.

The host extension exposes POST /api/agent/dialogue with text, optional identity, session, model, workspace and folder; it returns identity, session and answer. This is the persistent-dialogue endpoint for frontends. /api/tasks remains the bounded task endpoint. Concurrent writers to the same dialogue are refused. Memory updates use revision checks; an uncertain task submission is preserved and never blindly retried. User approvals must be answered through the task interface, not by the dialogue model.

Core run recovery and agent conversation recovery are distinct. Session schemas are checked on opening; incompatible data is not silently reinterpreted. Summaries retain raw source events and task references. Credentials are not stored in identity data.

0.1.2

• A conversation goes on until you end it. The agent's answer, a reply in plain text, ends its turn, not the conversation: the next message goes to the same conversation, which keeps its messages, the variables of its programs, its rules, its facts and the environment. What the agent left running goes on after the answer, and the end of a unit or an event starts its next turn without a message. Model calls and time are limits of a turn and begin anew with the next one; a turn that reaches one, fails or is cancelled (/cancel) ends with that reason and the conversation waits; cost is counted for the whole conversation. Every turn ends with a turn_result record. /clear is another name of /new. Sessions are kept on disk as they go (conversation.json beside the trace), and one that ended is continued in its own session id with a new kernel: harness --continue, harness --resume ID, harness run --continue | --session ID "task", harness sessions resume ID, /resume, Host.resume_session(); what lived in the old process (variables, rules, running programs) is gone, and the agent is told so. A sub-agent whose turn ended can be sent another message (send_agent) and goes on with its history. A conversation whose workspace is needed by another is parked, and its next message continues it. A run nobody talks to keeps its conversation as well: harness program CONFIG --continue EPISODE --message "..." gives the episode in that directory one more turn, in its own session, against the worker that runs. What breaks: the prompt no longer teaches <finish>; <finish> and finish() are still accepted and mean the same as a text answer. In a run without a user (a benchmark), a reply in plain text now ends the run as its answer instead of being sent back as a format error. A frontend that waited for FINISHED after an answer waits for the turn_result record instead (the state after it is IDLE, whose reason is how the turn ended); harness run "task" and the MCP server's run_task still end the session they started after its turn. A sub-agent's report has no question and no asks status: what it asks is its answer. ACP session/cancel ends the turn and keeps the conversation. A task the agent package gives (harness agent) ends with its turn, so a question it asks comes back as the task's answer. In summary.json, a conversation closed between turns keeps the status of its last turn; closed is a turn that was cut short. The evaluator's outcome is read when the conversation ends, as before, since a worker evaluates once. A kernel that dies ends the conversation; it is continued with --resume. Esc in the terminal chat still pauses.

0.1.0

• Add persistent identities, dialogue sessions, memory with revision checks, history search and context compression.
• Submit and follow bounded Harness tasks through the public host API; preserve task handles across dialogue restarts.
• Keep executable learning libraries separate from private personal memory.

0.1.1 (unreleased)

Import public task and model APIs through harness.sdk. Persistent-agent contract checks pass.