Cursor Origin, RAGFlow, Haystack, and Agno rebuild infrastructure under agents

The interesting work this week is happening under the agent, not in another chat demo. Cursor is treating source control as part of the runtime: Origin hosts git remotes in the same Codebase tab where cloud agents already open PRs, while mirrored GitHub projects keep GitHub as the system of record. That is a bet that agent commit velocity will outrun a forge designed for humans in a browser.

Retrieval stacks made the same bet. RAGFlow 0.27, the last major Python release before a Go rewrite, compiles a corpus into reusable Wiki, Graph, Tree, and Timeline artifacts, then lets retrieval loop. Haystack 3.1.0 and Agno 3.0.0 attack the complementary failure: tool-heavy agents that drown their own context. One drops old turns with a hook; the other writes oversized tool payloads out of the transcript.

If your agents live longer than a single prompt, pick where the code lives, how knowledge is compiled, and what you refuse to keep in the window.

Top Stories

Cursor Origin hosts git remotes next to agents, GitHub stays source of truth for mirrors Practical dev impact: Paid Cursor teams can claim a codebase namespace, push over HTTPS or the Origin CLI, and let agents open PRs in-editor while mirrored GitHub remotes keep receiving the writes. Origin is an early-beta git forge inside Cursor—repos, browsing, pull requests, GitHub sync, plus Vercel, Depot, and Buildkite apps. Native Origin remotes use `https://origin.cursor.com/{owner}/{repo}.git`; synced GitHub projects update in Origin but still treat GitHub as the system of record. Agents can create repos, comment on diffs, and drive branches from the same Codebase tab. Access is Pro/Teams/Enterprise only, staged, and the claimed namespace cannot be renamed during beta.

RAGFlow 0.27 compiles knowledge artifacts and adds multi-round Agentic Retrieval Practical dev impact: Stop treating manuals as a single vector dump—compile them into Wiki, Graph, Tree, Page Index, Mind Map, Timeline, or Skills, then pick Naive through Ultra retrieval depth per query. v0.27.0 is the last major Python backend; Infiniflow says the next line moves to Go and positions RAGFlow as an agent data foundation. Compilation is an ingestion-pipeline operator: Parser → Chunker → Compiler → Indexer, with artifacts inspectable per dataset or document. Agentic Retrieval decomposes claims, rewrites queries, and loops when evidence is thin. Medium and above spend more tokens; Ultra is for version diffs and cross-document attribution, not FAQ chat.

Haystack 3.1.0 CompactionHook trims agent context before the window fills Practical dev impact: Attach a `before_llm` CompactionHook so long tool loops drop old turns at 70% of the window instead of dying on context overflow. `SlidingWindowCompactor` keeps system prompts and the latest user task, removes complete historical turns first, and leaves a single omission note. `ToolResultPruningCompactor` is the better default for log dumps: it placeholders old tool payloads and keeps recent call/result pairs intact. Compaction is lossy and experimental. The same release adds `exit_reason`, `Agent.clone()`, `AgentTool` for nested agents, and token counters that estimate the request before the next call.

Agno 3.0.0 offloads oversized tool results and splits runs into `agno_runs` Practical dev impact: Set `offload_tool_results=True` so anything over 16k characters lands in AgentFS as a preview envelope; the model reads the rest on demand with `read_result` / `search_result`. Media can go to disk, S3, or GCS as a `MediaReference` instead of base64. Runs move out of the session JSON blob into `agno_runs`, cutting write amplification and lifting DynamoDB/Firestore item-size ceilings. This is a breaking release: run `MigrationManager(db).up()` (or `POST /databases/all/migrate`) before serving. Unmigrated databases raise typed errors. Culture APIs are gone; several Agent kwargs were renamed.

Practical Impact Analysis

Origin changes the default topology of an agentic team. Keep GitHub for Actions, issues, and public work, and give Cursor agents a first-class remote for PRs and previews. The beta is paid-only, staged, and namespace-locked once claimed—treat the codebase name as permanent. Enterprise admins can opt out; decide whether agent-created remotes are in scope before anyone pushes production history.

RAGFlow’s compilation step is the retrieval change that matters. If you still dump 200-page manuals into a single vector index, the new Wiki, Graph, and Timeline artifacts give agents a map instead of a lottery. Medium/High/Ultra retrieval will spend more tokens; reserve Ultra for version diffs and keep Naive for FAQ.

Haystack and Agno attack the same invoice. SlidingWindowCompactor is lossy—it deletes, it does not summarize. Prefer ToolResultPruningCompactor when agents fetch logs. Agno is stricter: oversized tool results become an envelope plus an on-demand read. Run MigrationManager before serving v3; stale databases now raise typed errors instead of failing quietly. The shared contract is simple: host, compiled knowledge, and a context cache you are willing to throw away.

Tutorial

Pin Haystack 3.1.0 and treat context as a cache with an eviction policy. CompactionHook runs on `before_llm`, estimates tokens from provider usage when present, and otherwise counts locally—including tool schemas. Leave headroom above `compact_at` for the next reply and its tool results. SlidingWindowCompactor is the right first switch for multi-turn chat; ToolResultPruningCompactor is the right switch for agents that pull inventories, traces, or HTML. Compaction does not summarize: deleted turns are gone. Wire `exit_reason` so a router can fall back when the step budget dies.

"""Haystack 3.1.0: compact a long-horizon agent before the window fills."""
import os

from haystack.components.agents import Agent
from haystack.components.generators.chat import OpenAIResponsesChatGenerator
from haystack.dataclasses import ChatMessage
from haystack.hooks.compaction import CompactionHook, ToolResultPruningCompactor
from haystack.tools import Tool

def scan_tree(path: str) -> str:
    """Return a verbose file listing — the kind of dump that blows context."""
    lines: list[str] = []
    for root, _, files in os.walk(path):
        for name in files:
            lines.append(os.path.join(root, name))

... click "Show full code" below to expand

"""Haystack 3.1.0: compact a long-horizon agent before the window fills."""
import os

from haystack.components.agents import Agent
from haystack.components.generators.chat import OpenAIResponsesChatGenerator
from haystack.dataclasses import ChatMessage
from haystack.hooks.compaction import CompactionHook, ToolResultPruningCompactor
from haystack.tools import Tool

def scan_tree(path: str) -> str:
    """Return a verbose file listing — the kind of dump that blows context."""
    lines: list[str] = []
    for root, _, files in os.walk(path):
        for name in files:
            lines.append(os.path.join(root, name))
    return "\n".join(lines) or f"empty:{path}"

scan = Tool(
    name="scan_tree",
    description="Walk a directory and return every file path.",
    function=scan_tree,
    parameters={
        "type": "object",
        "properties": {"path": {"type": "string"}},
        "required": ["path"],
    },
)

hook = CompactionHook(
    compactor=ToolResultPruningCompactor(min_keep_steps=2, min_tokens=200),
    context_window=400_000,
    compact_at=0.7,
    compact_to=0.4,
)

agent = Agent(
    chat_generator=OpenAIResponsesChatGenerator(
        model=os.getenv("HAYSTACK_MODEL", "gpt-5.4-nano"),
    ),
    tools=[scan],
    hooks={"before_llm": [hook]},
    system_prompt=(
        "You audit repositories. Call scan_tree, then name the three "
        "riskiest paths. Never paste the full listing back to the user."
    ),
)

if __name__ == "__main__":
    result = agent.run(
        [ChatMessage.from_user("Audit ./src and rank the riskiest files.")]
    )
    print(result["last_message"].text)
    print("exit_reason:", result.get("exit_reason"))

Install with `pip install ‘haystack-ai==3.1.0’`. Point `HAYSTACK_MODEL` at whatever your OpenAI-compatible Responses endpoint actually serves. If you need turn-level history instead of tool-result pruning, swap in `SlidingWindowCompactor()`. Implement the `Compactor` protocol only after you measure which messages your agents cannot afford to lose.

Grok Deep Dive

Cursor Origin, RAGFlow 0.27, Haystack 3.1.0, and Agno 3.0.0 all landed in the same 48-hour window and they argue the same architecture: agents need a writable git host, compiled knowledge rather than a single vector lottery, and a hard policy for tool dumps that used to live forever in the transcript. Design a production layout for a 12-engineer product team that already lives in GitHub Actions but runs Cursor cloud agents all day. Decide what belongs on Origin versus a GitHub mirror, when RAGFlow Ultra retrieval is worth the tokens versus Haystack Naive RAG, whether CompactionHook or Agno `offload_tool_results=True` should be the default for a log-scraping SRE agent, and what breaks if the Origin namespace is locked and Agno’s `MigrationManager` has not been run. Give a concrete repo topology, a context-eviction policy, and a one-sprint migration order.