Zero-token procedural execution for
autonomous AI agents

from semantic_harness import Agent, AgentConfig

class FinancialAnalyst(Agent):
    """You are an autonomous corporate financial analyst."""

    def calculate_margin(self, revenue: float, cost: float) -> float:
        """Compute gross profit margin percentage."""
        return ((revenue - cost) / revenue) * 100.0

agent = FinancialAnalyst(config=AgentConfig(model="qwen2.5-coder:3b", strategy="codeact"))

# Store enterprise metadata with ACT-R importance ranking
agent.long_term.remember(
    key="q4_targets",
    content="Q4 revenue target is $100M with max operating expense of $65M.",
    importance=0.95
)

# Run multi-turn task with persistent CodeAct variables
result = agent.run("Evaluate projected Q4 EBITDA margin based on target figures.")
print(result)

import { Agent, step } from "semantic-harness";
import { z } from "zod";

const UserProfileSchema = z.object({
  userId: z.number(),
  name: z.string(),
  activeSubscription: z.boolean(),
});

export class CustomerSupportAgent extends Agent {
  @step({ schema: UserProfileSchema, cache: true })
  async lookupUser(email: string) {
    // Re-executes verified AST without token inference on warm paths
    return await this.callLLM(`Fetch structured profile for ${email}`);
  }
}

from semantic_harness import ProceduralMemory, C2CValidator

proc_mem = ProceduralMemory(enable_fuzzy_search=True)

def validated_tool_node(state):
    intent = state["current_intent"]
    
    # 1. Zero-Token Fast Path Check
    cached_proc = proc_mem.lookup(intent)
    if cached_proc and cached_proc.is_reliable:
        state["result"] = cached_proc.execute(state["params"])
        state["tokens_used"] = 0
        return state

    # 2. Standard LLM Execution + C2C Validation
    raw_output = call_llm(state["prompt"])
    state["result"] = C2CValidator(state["schema"]).validate(raw_output)
    proc_mem.cache(intent, state["result"])
    return state