Sumanth (@Sumanth_077)

Continuous Intelligence dropped a new frontier time-series foundation model! ci-proto was built specifically for time-series forecasting, with a context window more than 60× longer than other time-series foundation models. Long context matters differently for time series. A forecast can depend on what happened millions of observations. Seasonal demand can repeat across years, equipment can drift gradually over long periods, and these recurring patterns can disappear completely if the model only sees the most recent window. ci-proto is designed to work with much longer histories directly when predicting what comes next. And because ci-proto is a foundation model, it is not limited to one dataset or industry-specific forecasting setup. The same pretrained model can be applied across different time-series datasets, from energy demand and generation to machine sensor readings and other sequential data. No fine tuning required. On fev-bench, a public benchmark designed to evaluate pretrained forecasting models across different datasets and domains, ci-proto just ranked #1#. And it is open weight, so you can download it and test it on your own data. I've shared the link to the GitHub repo in the comments!

Multi-agent workflows have a scaling problem! The agents inside the same workflow rarely need the same amount of capacity at the same time. Say you have a planner, multiple research agents, and a final synthesis agent. The planner might finish quickly while requests start piling up behind one of the research agents. Scaling the entire application would add capacity everywhere, even though only one part of the workflow actually needs it. CanyonOS is an open-source, workflow-aware platform for multi-agent Python applications and the harness between your agents. Each agent runs as a separate service with its own queue and replica limits, so the busy research agent can get additional capacity while the planner and synthesis agents stay where they are. It also handles communication between the agents and gives you visibility into what happens across the workflow after a request comes in. CanyonOS records the path a request took, including the agents it called, parallel branches, model usage, execution time, and estimated model costs. And you don't need to add tracing decorators or a separate instrumentation SDK throughout your agent code. You still integrate the workflow with CanyonOS, but tracing is handled at the platform layer. I also ran a multi-agent portfolio analysis workflow through it with separate agents working across three stocks. A single request produced 10 traceable steps across the workflow, and I could see which agents ran, where the LLM calls happened, how long each stage took, and the estimated model cost. For multi-agent applications, being able to operate each agent independently while still seeing the complete execution path becomes much more useful as the workflow grows. CanyonOS is open source. Link to the GitHub repo in the comments!

Web search for AI agents will never be the same! For AI agents, the search layer has to do more than retrieving relevant pages. It has to return the context the model can actually use efficiently. Keenable just released 1.0, and it’s now the top-performing web search API for AI agents across the benchmarks that matter. It ranks first on Artificial Analysis for search quality, and first overall on NEEDLE, its open benchmark that continuously reruns on new queries. Keenable owns the full search stack instead of sitting on top of another search API. That gives it control over how results are retrieved, ranked, compressed, and returned to the agent. It also means the team can keep improving the search layer around the queries agents are actually sending through the system. When search results go directly back into the model as context, returning more text is not always better. It increases token usage and can bury the information the model actually needs for the task. Keenable 1.0 introduces dynamic snippets that return more focused context for each query. Keenable reports that this cuts token consumption by 50% on research tasks. It also adds 100M knowledge cards for queries where structured information is more useful than another set of webpages. For AI agents, web search is becoming part of the reasoning stack itself. Retrieval quality, recency, context size, and cost all affect what the agent can do with the information it finds.

DeepSeek open-sourced a prototype for an autonomous coding agent! dsh-superagent is a proactive coding agent for a single GitHub repository, packaged as a bundle for DeepSeek Harness. Instead of treating every request as a separate coding session, it turns incoming work into persistent tasks that the agent can continue working on over time. Each task gets its own agent session, working directory, branch state, execution history, and pending inputs, which allows multiple tasks to run independently without mixing their context. There is also an authorization layer before any work starts. A request has to come from an allowed source or match an explicit rule before the agent can act on it. Once authorized, the task is assigned to an executor that can inspect the repository, make changes, and eventually return the result through the original conversation or open a PR. The persistent state is especially useful when a task spans multiple interactions. If the agent needs clarification, it can pause while keeping the same task and session alive. Follow-up messages are then routed back to that existing context instead of starting another coding session from scratch. The same applies to failures and restarts. The system keeps enough task state to recover ongoing work rather than losing everything when the service restarts. DeepSeek also separates reactive and proactive behavior. The agent doesn’t continuously invent work for itself. It acts when someone explicitly asks it to, or when a written rule gives it permission to act proactively. So the autonomy here comes from more than just giving a coding model access to tools. It comes from persistent task state, isolated agent sessions, authorization rules, concurrent execution, recovery, and GitHub-native outputs working together around the model. I’ve shared the GitHub repo in the comments!

I built a data analyst agent with Jev as the review layer! Qwen handles the main agent work, Jev acts as the review layer, and Vercel eve runs the agent loop, tool execution, and human approval flow. The agent takes a plain-English question about the data, inspects the database schema, writes the SQL, runs the query, and explains the result. The interesting part is what happens around that main loop. Qwen is responsible for generating the SQL and the final answer, while Jev reviews the parts where semantic judgment is actually useful. Anything that can be checked reliably with code stays deterministic. Jev reviews the agent at three points: - Before the agent starts, it checks whether the user's question is clear enough to answer from the available data. - After Qwen generates the SQL, it checks whether the query actually represents what the user asked. - After the query runs, it checks whether the final explanation is grounded in the returned rows. For example, we tested it with: “Who is our best customer?” The question sounds simple, but “best” could mean highest revenue, most purchases, highest average order value, or something else. Instead of letting Qwen silently choose a metric, Jev flagged the question as ambiguous and asked for clarification. The same separation applies to SQL execution. Qwen can propose a query, but it cannot decide whether that query is safe to run. The tool accepts only a single read-only `SELECT`, SQLite runs in read-only mode, results are capped at 200 rows, and queries without a `WHERE` clause can require human approval before execution. Those checks do not need another model call. But a query can be completely safe and still answer the wrong question. A deterministic rule can verify that the SQL is read-only. It cannot reliably judge whether a query for “revenue last month” accidentally calculates revenue across all time. That is where Jev comes in. It reviews the proposed SQL against the original question and schema before execution. After the rows come back and Qwen writes the explanation, Jev reviews that answer again to check whether the claims are actually supported by the returned data. The project uses a local SQLite sales database, Qwen through the Vercel AI Gateway, Gradio for the interface, and only two database tools: "inspect_schema" and "run_sql". No single model is responsible for everything. Qwen generates, Jev reviews, deterministic code controls execution, and Vercel eve manages the agent loop and approval flow. GitHub Repo: 100% open source.

Python framework for building real-time voice agents! Pipecat is an open-source framework for orchestrating audio, video, AI services, transports, and conversation pipelines. Voice-first architecture with pluggable components. What you can build: voice assistants, AI companions, multimodal interfaces, interactive storytelling, business agents like customer support and intake, and more complex dialog systems. The framework handles speech recognition, text-to-speech, conversation logic, and real-time interaction. WebRTC and WebSocket transport are built in, with a focus on low-latency conversations. Why Pipecat: • Voice-first: integrates STT, TTS, and conversation handling in one framework • Pluggable: supports multiple AI service providers for each capability • Composable pipelines: build more complex behavior from modular components • Real-time: designed for streaming audio/video interactions One thing that becomes important with frameworks like this is what happens before speech even reaches the STT layer. I went deeper into that in the article I’m quoting below, especially around the second-speaker problem and why accurate transcription alone is not enough for reliable voice agents.

Learn Harness Engineering from scratch! This repo is a full learning path around harness engineering, with 14 lectures, 8 projects, reusable templates, and hands-on exercises. The course focuses on the environment around coding agents and how that environment affects whether an agent can reliably work inside a real repository across longer tasks and multiple sessions. It starts with the fundamentals of harness engineering and gradually gets into things like repository structure, persistent state, task boundaries, verification, observability, session handoffs, automated loops, and graph engineering. A harness in this context has five core parts: - Instructions that tell the agent how to work inside the repo - State that persists progress across sessions - Verification through tests, linting, type checks, and full-pipeline runs - Scope controls that keep the agent focused on one task at a time - Session lifecycle so every run starts and ends in a usable state The projects are also connected rather than being isolated examples. You keep working on the same Electron-based knowledge app while gradually improving the harness around it. You start by comparing prompt-only vs. rules-first agents, then build multi-session continuity, runtime feedback, verification, a complete harness, automated maker-checker loops, and eventually represent the workflow as a graph with parallel execution, rollback, and human approval. What I like is that you can actually take parts of the repo and use them directly in your own projects. There are templates for things like "AGENTS. md", "init. sh", feature lists, progress tracking, loop state, maker-checker prompts, and a "harness-creator" skill that can scaffold the basic harness structure for an existing project. The repo also covers the progression from a single agent loop to graph engineering, including when you actually need nodes, shared state, routing, parallelism, and recovery instead of forcing everything into one loop. A solid resource if you're working with coding agents and want to understand the engineering around making them reliable over longer tasks. 100% open source

Jev for semantic code search! jevgrep is a CLI for coding agents that helps them find relevant code when they know what a behavior does, but not where it lives in the repository. Instead of relying only on exact strings, filenames, or symbols, you can ask a repository-level question like: “Where is authentication checked before a request reaches a handler?” Jevgrep explores the repository, uses Jev to judge relevance across folders, files, and declarations, and returns the relevant file locations along with verbatim source excerpts and line references. The coding agent still does the actual work after that. It reads the returned source, opens the surrounding files, makes the change, and runs the tests. Jev is only being used inside the retrieval layer to decide which parts of the codebase are worth looking at. If you already know the exact symbol, filename, or string, tools like 'grep', 'rg', or direct file search are still the better fit. Jevgrep is aimed at the harder case where you understand the behavior you are looking for, but you do not yet know how the repository names or organizes it. The repo also includes an agent skill for tools like Claude Code, Codex, and OpenCode, so the agent can use 'jg' during repository discovery instead of you manually running the search every time. They also tested the approach on a small 10-task SWE-bench setup. In one reported run, both Jevgrep and the no-Jev baseline solved 8/10 tasks, while coding-agent cost dropped from $7.62 to $5.44, excluding Jev cost. Interesting use of Jev as a relevance layer 100% open source. Link to the GitHub repo in the comments!

Accurate STT is not enough for reliable voice agents! Modern speech-to-text is already very good at handling things like traffic, keyboards, air conditioning, and other background noise. Another human voice is a different problem. If someone nearby starts talking while you are speaking, the STT model is no longer trying to separate speech from noise. It is receiving two valid speech signals and has to decide which one actually belongs to the user. For a voice agent, that can become much more than a transcription error. The wrong speaker can change the perceived intent, trigger a turn the user never intended, or influence what the agent does next. I went through Krisp's public Voice Isolation benchmark to see how much difference the audio layer makes before anything reaches the STT model. Across 265 real recordings and 11 STT configurations, pooled word error rate dropped from 23.3% on raw audio to 6.2% after Voice Isolation. The environment breakdown makes the result more useful: - Work: 31.8% → 6.3% WER - Call Center: 23.9% → 6.9% WER - Phone Calls: 3.5% → 3.9% WER That last one matters. When there is very little competing speech, Voice Isolation does not magically improve everything. In some cases it can slightly hurt transcription. The gains show up where the second-speaker problem actually exists. And I think that is the more important point for voice agents. There are really two questions: Did we transcribe the words correctly? Did we transcribe the right person? For a voice agent that can call tools, update memory, retrieve information, or take actions, the second one can be just as important as the first. The pipeline really starts before STT: Microphone → Voice Isolation → Speech-to-Text → Turn Detection → Agent → Tools → Response A stronger LLM later in the stack cannot recover the user's original intent if the wrong speaker already made it into the transcript. I’ve shared the benchmarks below

I built a Voice AI agent that books appointments over live phone calls! 100% open source. Runs on GLM-5.3 Flash through Telnyx, about $0.30 per booking call. The agent can handle the complete booking workflow during a real call: understand what the caller needs, check available time slots, collect the required details, book the appointment, generate a calendar invite, and confirm everything back to the caller. What makes this more than a simple voice chatbot is the tool layer behind the conversation. At the start of every call, the agent receives context like the current date, business hours, and available services. When the caller asks for a specific day or time, the agent checks the scheduling system and only offers slots that are actually available. Once the caller picks a time, it books the appointment, stores the details in a lightweight CRM, and generates a calendar invite. For the model layer, I used GLM-5.3 Flash through Telnyx Inference. It powers the agent during the call, and the same model is used after the call to turn the call summary into a personalized follow-up. GLM-5.3 Flash runs on Telnyx's own GPUs, so the open model is served directly through their inference infrastructure rather than adding a closed-model API markup on top. The overall flow looks like this: Caller → Voice Agent → Check availability → Book slot → Create calendar invite → Store CRM record → Generate follow-up GitHub: For the voice stack, I used Telnyx Voice AI. Telephony, speech-to-text, GLM-5.3 Flash inference, text-to-speech, and the agent itself all run through Telnyx with one API key and one bill, while the application handles the scheduling logic, booking tools, CRM, calendar invite, and post-call workflow. The scheduling layer is modular, so the same setup can be connected to Google Calendar, Outlook, Cal, or another booking system.

I built a self-directed data analyst! 100% Open Source The agent investigates a given dataset on its own without requiring you to guide it through every step. Give it a dataset and an objective like “Why did revenue decline?”, and it decides what to inspect, which analyses to run, what hypotheses to test, and what to investigate next based on the evidence it finds. It can inspect the data, run SQL, use Python for deeper analysis, create charts, form hypotheses, test them against the dataset, and keep following new evidence until it has enough to explain what happened. There is no fixed sequence telling it what analysis to run next. Each result becomes context for the next decision. If a query fails, the agent can use that error to adjust its approach. If it starts repeating similar analyses without making progress, the harness can detect that and push it to reassess the investigation. It also keeps explicit state across the run, including findings, hypotheses, tool history, and usage, instead of relying only on raw conversation history. For the model layer, I used Liner Mark 1.0. This works well for this kind of setup because one investigation can involve many model calls, but every step does not need the same level of reasoning. Liner Mark 1.0 routes each request to an appropriate underlying model while exposing a single model interface to the agent. So the same loop can move between dataset inspection, query planning, hypothesis evaluation, error recovery, and final synthesis without manually choosing a different model for every step. The workflow looks like this: Dataset + Objective → Investigate → Run SQL/Python → Observe → Update Hypotheses → Decide Next Step → Repeat → Final Report At the end, the agent returns the root cause, supporting findings, hypotheses it tested, relevant charts, recommended next steps, and a usage breakdown. GitHub repo: What I like about this setup is that the analysis path is not predetermined. You start with a goal, inspect the evidence, form a theory, test it, and let the results decide what to investigate next.

Stop generating text when all you need is a decision! Jev is TypeSafe AI’s first “System One” model, built for a part of AI systems that we currently keep forcing generative LLMs to handle: making bounded decisions inside software. Think about what happens during an agent run. The main model may be writing code, researching, planning, or reasoning through a problem, but the system around it is constantly making smaller decisions. Which model should handle the next step? Does this tool call need approval? Is the agent still making progress? Is the task actually complete? Today, we often send those questions back to another generative LLM. Even with structured outputs, the model is still generating tokens sequentially and constraining them into the schema we asked for. The application then takes that generated output and turns it back into the decision it needed in the first place. Jev removes string generation from that loop. You give it the current state and define the decisions you care about. Those can be a yes/no judgment, a choice between predefined options, or a score across an ordered scale. Jev returns typed answers with probabilities that the application can use directly. That distinction becomes useful when these decisions sit everywhere inside an agent harness. A coding agent can use the main LLM to understand a repository and write a fix, while Jev handles model routing, tool gating, risk checks, progress evaluation, or deciding whether another iteration is actually necessary. And Jev should not become the permission system either. A probability that an action is safe is still a model judgment. Permissions, spend limits, allowlists, and other hard constraints should remain deterministic. The architecture I find more interesting is the separation itself: generative models do the open-ended work, decision models handle fuzzy but bounded judgments around that work, and the runtime decides what is actually allowed to happen. As agents become longer-running, the number of these small decisions only increases. Using a full generative model for every one of them may turn out to be a very expensive abstraction. If you want a deeper look at Jev, I also wrote a separate breakdown of how it works. I’ve quoted the article below.

I built a self-evolving code review agent! Most code review agents use the same prompt every time they run. They can review a diff and generate comments, but they do not remember what your team accepted, rejected, or corrected in previous reviews. That means the same mistakes can keep showing up across review cycles. This project adds persistent experiential memory to the review loop. Before every review, the agent retrieves relevant team rules and similar past review trajectories from memory, then uses that context alongside the current diff to generate review comments. After the review, the engineer can accept, reject, or edit every comment. That feedback becomes the learning signal. Accepted comments reinforce useful rules. Rejected comments create lessons about what should not be flagged. Edited comments refine the team’s preferred convention, scope, or wording. The agent adapts non-parametrically. Instead of fine-tuning the underlying model, it improves by storing review outcomes as reusable memory and retrieving the most relevant experience before the next review. Here is how the loop works: • Retrieve: search memory for relevant insights and similar past reviews before generating comments • Review: generate structured feedback using the current diff plus retrieved memory • Human feedback: pause the workflow and collect an accept, reject, or edit decision for every comment • Reflect: convert those decisions into reusable natural-language rules with rationale, polarity, scope, and confidence • Persist: store both the learned insights and complete review trajectory for future retrieval Over time, the agent builds a memory of how your team actually reviews code without retraining the underlying model. The full workflow runs locally with LangGraph, Ollama, BGE embeddings, and a vector database for long-term memory. The interesting part is that every review leaves behind experience that can be retrieved and reused on the next one. Github Repo:

ByteDance dropped a banger paper on self-evolving agent harnesses! HarnessDev evaluates whether AI agents can build a runnable harness from scratch and iteratively improve it using execution feedback. Most agent benchmarks keep the harness fixed and only evaluate the model inside it. HarnessDev changes the target of evaluation itself. The agent starts from a minimal seed, builds the harness around the task, runs it, observes what worked or failed, and then modifies that harness across multiple iterations. That means the agent is not only solving the task. It is also changing the planning, memory, tool use, state management, and execution logic around itself. The paper evaluates this in two stages: • Creation: can the model build a complete runnable harness from a minimal starting point? • Evolution: can it improve that harness using feedback from previous runs? The interesting part is that runnable does not automatically mean better. Some generated memory and state mechanisms existed in the code but were barely used during execution, and improvements on visible feedback did not always transfer to held-out tasks. Only 34 of 64 harness changes moved in the same direction on both visible feedback and held-out evaluation, and only 2 of 9 final harness versions were actually the best-performing version on the held-out set. So the paper is really exposing a new challenge: Agents can already start modifying the infrastructure they run on. The harder part is making sure those changes actually generalize. I've shared the paper in the comments!

Loop vs Graph Engineering: Clearly Explained! A loop is an autonomous cycle where an agent plans, acts, verifies the result, and keeps iterating until it reaches a stopping condition. The basic pattern is simple: Plan → Act → Verify → Repeat Loop engineering is about making that cycle reliable. You decide what context survives between iterations, how the agent evaluates its own work, when it should retry, how failures are handled, and what condition finally ends the run. This works well when one agent can own a coherent task from start to finish. The problem starts when the work itself becomes more structured. Some tasks need to happen in parallel. Different agents may need different context, tools, memory, or permissions. Certain steps may require human approval, while others can continue automatically. At that point, trying to force everything through one loop makes the system harder to reason about. That is where graph engineering becomes useful. A graph makes the workflow explicit. Nodes represent units of work such as agents, tools, validators, or deterministic functions, while edges define how state and control move between them. The important part is that loops and graphs are not competing architectures. A loop can itself be one node inside a larger graph. For example, a research agent may run its own Plan → Act → Verify loop, while a separate analysis agent runs another loop. A graph can then coordinate when those agents start, what context they receive, how their outputs are combined, and what happens next. So the practical distinction is: • Loop Engineering: design one autonomous execution cycle around a task • Graph Engineering: design how multiple execution cycles, tools, and decision points coordinate through shared state and explicit control flow You usually start with a loop when one agent can handle the task end to end. You move to a graph when the work needs parallel execution, specialized agents, different permissions, explicit branching, or clearer control over how state moves through the system. Graph engineering does not replace loop engineering. It becomes useful when one loop is no longer enough to hold the workflow together. I've shared the full article in the comments!

Your AI agent doesn’t need a better model. It needs a better harness! JIT-Agent is a compact meta-agent that writes your agent harness on the fly. Most agent systems use a fixed scaffold for every task. The same planner, the same memory setup, the same tool orchestration, and the same execution strategy regardless of what the agent is actually trying to solve. JIT-Agent changes that by generating a task-specific harness across four core modules: memory, planning, action, and capability orchestration. So instead of treating the harness as static infrastructure, it becomes something the agent can compose based on the task itself. It can also improve that harness from execution traces and feedback without updating the generator model. This matters because a large part of agent performance comes from everything around the model. How context is stored, how the task is decomposed, which tools are available, when they are called, and how the execution loop is structured can change the final result significantly. The benchmarks make that pretty clear. With JIT-Agent, DeepSeek-V4-Flash outperformed GPT-5.6 by 9.1 points on DeepSearchQA and 4.3 points on OdysseyBench. GLM-5.2 also improved by up to 20.2 points with a better generated harness. Same model family. Better harness. Better agent. That is the part I find most interesting. As agent systems get more complex, improving the model may not always be the highest-leverage move. Improving the harness around it might matter just as much. 100% open source. I've shared the GitHub repo and paper in the replies!