mfpiccolo

53 things from ~4 months of running an agent harness in production.

iii, the engine that powers the harness, is really cool too: https://iii.dev/docs/install

• crash mid tool call left a dangling call with no result that poisoned every later request workers#507 workers#630
• resumed turn raced the worker booting and called a function that wasn't registered yet workers#507
• no durable queue for turns so wedged ones sat in running forever workers#464
• cut stream parsed as null args and got reported as a successful empty turn workers#878
• seven providers treating any connection close as done workers#878
• cached tokens double billed on six providers workers#740

mfpiccolo

Motia: Skip the Protocols, Ship the Product (and Still Speak Them When You Must)

TL;DR Motia collapses APIs, AI agents, cron/background jobs and into a single event‑driven step model. Most of the time, formal layers like MCP (Model Context Protocol), A2A (Agent‑to‑Agent), and runtime Tool‑Use are unnecessary—plain JSON events and SDK calls get the job done with much less ceremony. If you do need MCP/A2A to talk to a partner, Motia can emit or consume those packets through a thin adapter step, so you remain interoperable without letting protocol complexity infect your codebase.

---

1 · The Landscape in 60 Seconds

Acronym	Purpose	Hidden Cost

mfpiccolo

{
  "rules": [
    // File Structure Rules
    {
      "name": "enforce-step-file-naming",
      "description": "Ensure step files follow the *.step.{ts,js,py,rb} naming convention",
      "pattern": "\\b(?!.*\\.step\\.(ts|js|py|rb)$).*step\\b",
      "severity": "error",
      "message": "Step files must follow the pattern: filename.step.{ts|js|py|rb}",
      "example": {

mfpiccolo

// I am trying to decide on an API for blue-chip's virtual models.

class Owner extends BaseModel {
  static get hasMany() {return [Dog]}
}
class Dog extends BaseModel {
  static get belongsTo() {return [Owner]}
}

class VirtualOwner extends BaseModel {

mfpiccolo

api_config = {
  base_url: 'http://localhost:8065/api/v3',
  defaluts: { // if none passed here then use JSON.parse()
    success_deserializer: successJsonApiDerserializer,
    error_deserializer: errorJsonApiDerserializer,
    // has the same defaults as fetch
  },
  resources: {
    all_team_listings: {
      endpoint: 'teams/all_team_listings',

mfpiccolo

var diesel = require("diesel")
var User = require('User');

diesel.config({
  infer_schema = true
  infer_models = true      # I was thinking this would create Queriable structs with sane defaults based on schema
  database_url = "postgres://localhost/ruby_diesel_dev"
  model_mapping: {
    users: User
  }

mfpiccolo

use sqlite::Sqlite;
use types::{self, FromSql, FromSqlRow, HasSqlType, Numeric, Float};
use std::error::Error;
use sqlite::connection::SqliteValue;
use std::str::FromStr;
use query_source::Queryable;
use row::Row;

#[derive(Debug, Clone, PartialEq, PartialOrd)]
pub enum SqliteNumeric {

mfpiccolo

impl<T, U> ToJsonApi for Vec<(T, Option<U>)>
where T: ToResourceObject + Default, U: ToResourceObject
{
  fn serialize(&self) -> String {
    self.into_iter().group_by(|&&(a, b)| a)
      .map(|(c, d)| d.into_iter().filter_map(|(e,f)| f).collect())
      .collect();

  "some".to_string()
  }

mfpiccolo

#![feature(custom_derive, core)]

extern crate core;
use std::io;
use std::io::prelude::*;
use core::fmt::Debug;

#[derive(Debug)]
struct Product {
    id: i32,

mfpiccolo

pub trait Converter {
  fn blah(&self) -> &String;
}

struct This {
  convert: String,
}
struct That {
  convert: String,
}