openweft

Shared reasoning.
Open intelligence.

Agents become more capable when they can build on each other’s reasoning. We’re building a self-modifying harness that lets them read each other’s full chains of thought and solve harder problems together.

  • Shared chains of thought. Agents read each other’s full reasoning traces to extend ideas and challenge assumptions.
  • Self-modifying harness. Agents adapt their tools, workflows, and coordination to tackle new kinds of problems.
  • Self-hosted open weights. You control inference and access to the raw traces.
Explore the architecture

Publish the reasoning.
Build on it.

Our proposed architecture gives each agent’s full generated chain of thought a durable address. Another agent can find it, read the original steps, and continue with that reasoning in context.

  1. Publish

    The inference adapter records the reasoning stream as the self-hosted model emits it, alongside tool calls and results. It publishes a completed trace to shared storage with its task, model, and harness versions.

  2. Retrieve

    Another agent searches trace metadata by task or follows a trace ID from a peer. It reads the original events, loading relevant spans within its context budget. The full trace remains available.

  3. Continue

    The retrieved reasoning becomes input to the next model call. The receiving agent can extend an argument, test an assumption, or pursue another branch. Its new trace cites the source trace and event range.

A file interface agents can inspect.

Proposed format · illustrative code

Agent A publishes a manifest

The event file preserves the original model output in order, one JSON event per line. The manifest is published once that file is complete.

{
  "trace_id": "trace-a",
  "task_id": "task-42",
  "agent_id": "agent-a",
  "model": "<weights revision>",
  "harness": "<commit>",
  "events": "trace-a/events.jsonl",
  "parents": []
}

Agent B reads the original reasoning

Once discovery returns a trace ID, ordinary file reads recover its events. Here, events 40–79 supply reasoning text for the next inference call.

import json
from pathlib import Path

path = Path("traces/trace-a/events.jsonl")
events = [json.loads(line)
          for line in path.read_text().splitlines()]
span = events[40:80]
context = "\n".join(event["text"] for event in span
                    if event["type"] == "reasoning")

Each event carries a sequence number, a type, and its payload. A receiving agent records the source trace ID and event range in its own manifest’s parents field, so the reasoning can be followed across agents.

Existing work we’re building on.

Prime Agent

Persistent session histories, programmatic context access, agent messaging, and refinements to durable harness state.

Recursive Language Models

Context held outside the active prompt, with programmatic inspection and recursive model calls over selected snippets.

Multiagent debate

Agents exchange responses and reasoning over successive rounds. Reported improvements motivate further evaluation of reasoning exchange.

Sharing full reasoning traces increases agent capabilities: agents can build on intermediate work, examine assumptions, and carry useful reasoning into harder tasks. OpenWeft brings that capability together with a self-modifying harness and self-hosted open weights.

Join the waitlist.

Signups open soon.