Packages

import { createGuard } from '@waymakerai/aicofounder-guard';

const guard = createGuard({
  pii: 'redact',
  injection: 'block',
  toxicity: 'block',
  budget: { limit: 50, period: 'day', warningAt: 0.8, action: 'block' },
});

const result = guard.check(userInput, { model: 'claude-sonnet-4-20250514' });
if (result.blocked) {
  console.log('Blocked:', result.reason);
} else {
  const safeInput = result.redacted || userInput;
  // Send safeInput to LLM
}

import { createCoFounder } from '@waymakerai/aicofounder-core';

const cofounder = createCoFounder({
  providers: {
    anthropic: process.env.ANTHROPIC_API_KEY!,
    openai: process.env.OPENAI_API_KEY!,
  },
  cache: true,
  optimize: 'cost',
});

const response = await cofounder.chat('Explain quantum computing');

import { PolicyEngine, hipaaPolicy, gdprPolicy, compose } from '@waymakerai/aicofounder-policies';

const policy = compose([hipaaPolicy, gdprPolicy], 'strict');
const engine = new PolicyEngine([policy]);

const result = engine.evaluate(text, { model: 'claude-sonnet-4-20250514', direction: 'output' });
console.log(result.allowed, result.violations);

import { ComplianceEnforcer, PresetRules } from '@waymakerai/aicofounder-compliance';

const enforcer = new ComplianceEnforcer({
  rules: [PresetRules.hipaaNoMedicalAdvice(), PresetRules.secFinancialDisclaimer()],
  strictMode: true,
});

const result = await enforcer.enforce(userInput, aiOutput, { topic: 'medical' });
if (!result.compliant) {
  console.log('Violations:', result.violations);
}

import { GuidelineManager, PresetGuidelines } from '@waymakerai/aicofounder-guidelines';

const manager = new GuidelineManager();
await manager.addGuideline(PresetGuidelines.noMedicalAdvice());

const matched = await manager.match({ topic: 'medical', message: 'I have a headache' });

import { EvidenceCollector, ReportGenerator } from '@waymakerai/aicofounder-soc2';

const collector = new EvidenceCollector();
const report = new ReportGenerator(collector);
const pdf = await report.generate('Type II', { period: 'Q1 2026' });

import { createGuardedAgent } from '@waymakerai/aicofounder-agent-sdk';

const agent = createGuardedAgent({
  model: 'claude-sonnet-4-20250514',
  instructions: 'You are a helpful assistant.',
  guards: {
    pii: { mode: 'redact', onDetection: 'redact' },
    injection: { sensitivity: 'medium', onDetection: 'block' },
    cost: { budgetPeriod: 'day', warningThreshold: 0.8 },
    audit: { destination: 'file', filePath: './audit.log', tamperProof: true },
  },
});

const result = await agent.run('Help me with my account');

import { createMessageBroker, createChannel } from '@waymakerai/aicofounder-agents';

const broker = createMessageBroker({ deliveryGuarantee: 'at-least-once' });
const tasks = createChannel<{ task: string }>({ name: 'tasks', type: 'topic' });

broker.subscribe(tasks, async (msg, ctx) => {
  console.log('Task:', msg.payload.task);
  await ctx.acknowledge();
});

import { summarize, classify, extract } from '@waymakerai/aicofounder-helpers';

const summary = await summarize(document, { style: 'brief' });
const category = await classify(email, ['support', 'sales', 'billing']);
const data = await extract(resume, { name: 'string', skills: 'string[]' });

import { PromptManager } from '@waymakerai/aicofounder-prompts';

const pm = new PromptManager({ workspace: 'my-app' });
await pm.register('greeting', { template: 'Hello {{name}}!', variables: ['name'] });
const result = await pm.execute('greeting', { variables: { name: 'World' } });

import { RAGPresets } from '@waymakerai/aicofounder-rag';

const pipeline = RAGPresets.balanced();
await pipeline.index([{ id: 'doc1', content: 'Your docs...' }]);
const result = await pipeline.query({ query: 'How does auth work?' });
console.log(result.answer, result.citations);

import { ContextOptimizer } from '@waymakerai/aicofounder-context-optimizer';

const optimizer = new ContextOptimizer({ strategy: 'hybrid', maxTokens: 400000 });
const result = await optimizer.optimize({ files: repoFiles, query: 'Explain auth flow' });
console.log(result.tokens, result.costSavings);

# Create a new project
npx @waymakerai/aicofounder-cli init my-app

# Generate code
rana generate api --schema ./schema.yml

# Run AI tests
rana test --semantic --coverage

# Scan your codebase
npx @waymakerai/aicofounder-ci scan --rules all --fail-on high

# GitHub Actions
- uses: waymaker-ai/cofounder-ci@v1
  with:
    rules: all
    fail-on: high
    comment-on-pr: true

import { TestRunner } from '@waymakerai/aicofounder-testing';

const runner = new TestRunner({ semantic: true });
await runner.run([
  { input: 'Summarize this...', expected: 'A brief overview...', threshold: 0.8 },
]);

import { StreamGuard, AnthropicAdapter } from '@waymakerai/aicofounder-streaming';

const guard = new StreamGuard({ pii: 'redact', injection: 'block' });
const stream = guard.wrap(anthropicStream, new AnthropicAdapter());

import { CoFounderProvider, useChat } from '@waymakerai/aicofounder-react';

function App() {
  return (
    <CoFounderProvider config={{ apiKey: '...' }}>
      <ChatComponent />
    </CoFounderProvider>
  );
}

import { Dashboard } from '@waymakerai/aicofounder-dashboard';

const dashboard = new Dashboard({ port: 3001, storage: 'file' });
await dashboard.start();
// Open http://localhost:3001

import { MCPServer } from '@waymakerai/aicofounder-mcp-server';

const server = new MCPServer({ tools: ['guard', 'compliance', 'rag'] });
await server.start();

import { BenchmarkRunner } from '@waymakerai/aicofounder-benchmark';

const runner = new BenchmarkRunner();
const results = await runner.compare(['claude-sonnet-4-20250514', 'gpt-4o'], {
  prompts: testPrompts,
  metrics: ['latency', 'cost', 'quality'],
});